blob: bce53ac81096afc3e559a7317c149918290bab34 [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"
Dave Chinner70a9883c2013-10-23 10:36:05 +110020#include "xfs_shared.h"
Dave Chinner239880e2013-10-23 10:50:10 +110021#include "xfs_format.h"
22#include "xfs_log_format.h"
23#include "xfs_trans_resv.h"
Nathan Scotta844f452005-11-02 14:38:42 +110024#include "xfs_bit.h"
Nathan Scotta844f452005-11-02 14:38:42 +110025#include "xfs_inum.h"
Nathan Scotta844f452005-11-02 14:38:42 +110026#include "xfs_sb.h"
27#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "xfs_mount.h"
Dave Chinner57062782013-10-15 09:17:51 +110029#include "xfs_da_format.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include "xfs_inode.h"
Dave Chinner239880e2013-10-23 10:50:10 +110031#include "xfs_trans.h"
Dave Chinner239880e2013-10-23 10:50:10 +110032#include "xfs_log.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include "xfs_log_priv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_log_recover.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110035#include "xfs_inode_item.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_extfree_item.h"
37#include "xfs_trans_priv.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110038#include "xfs_alloc.h"
39#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "xfs_quota.h"
Christoph Hellwig0e446be2012-11-12 22:54:24 +110041#include "xfs_cksum.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000042#include "xfs_trace.h"
Dave Chinner33479e02012-10-08 21:56:11 +110043#include "xfs_icache.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110044#include "xfs_bmap_btree.h"
45#include "xfs_dinode.h"
46#include "xfs_error.h"
Dave Chinner2b9ab5a2013-08-12 20:49:37 +100047#include "xfs_dir2.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Dave Chinnerfc06c6d2013-08-12 20:49:22 +100049#define BLK_AVG(blk1, blk2) ((blk1+blk2) >> 1)
50
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -050051STATIC int
52xlog_find_zeroed(
53 struct xlog *,
54 xfs_daddr_t *);
55STATIC int
56xlog_clear_stale_blocks(
57 struct xlog *,
58 xfs_lsn_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#if defined(DEBUG)
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -050060STATIC void
61xlog_recover_check_summary(
62 struct xlog *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#else
64#define xlog_recover_check_summary(log)
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#endif
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067/*
Christoph Hellwigd5689ea2010-12-01 22:06:22 +000068 * This structure is used during recovery to record the buf log items which
69 * have been canceled and should not be replayed.
70 */
71struct xfs_buf_cancel {
72 xfs_daddr_t bc_blkno;
73 uint bc_len;
74 int bc_refcount;
75 struct list_head bc_list;
76};
77
78/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 * Sector aligned buffer routines for buffer create/read/write/access
80 */
81
Alex Elderff30a622010-04-13 15:22:58 +100082/*
83 * Verify the given count of basic blocks is valid number of blocks
84 * to specify for an operation involving the given XFS log buffer.
85 * Returns nonzero if the count is valid, 0 otherwise.
86 */
87
88static inline int
89xlog_buf_bbcount_valid(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -050090 struct xlog *log,
Alex Elderff30a622010-04-13 15:22:58 +100091 int bbcount)
92{
93 return bbcount > 0 && bbcount <= log->l_logBBsize;
94}
95
Alex Elder36adecf2010-04-13 15:21:13 +100096/*
97 * Allocate a buffer to hold log data. The buffer needs to be able
98 * to map to a range of nbblks basic blocks at any valid (basic
99 * block) offset within the log.
100 */
Eric Sandeen5d77c0d2009-11-19 15:52:00 +0000101STATIC xfs_buf_t *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102xlog_get_bp(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500103 struct xlog *log,
Dave Chinner32281492009-01-22 15:37:47 +1100104 int nbblks)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
Christoph Hellwigc8da0fa2011-07-08 14:36:25 +0200106 struct xfs_buf *bp;
107
Alex Elderff30a622010-04-13 15:22:58 +1000108 if (!xlog_buf_bbcount_valid(log, nbblks)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100109 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
Alex Elderff30a622010-04-13 15:22:58 +1000110 nbblks);
111 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
Dave Chinner32281492009-01-22 15:37:47 +1100112 return NULL;
113 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Alex Elder36adecf2010-04-13 15:21:13 +1000115 /*
116 * We do log I/O in units of log sectors (a power-of-2
117 * multiple of the basic block size), so we round up the
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300118 * requested size to accommodate the basic blocks required
Alex Elder36adecf2010-04-13 15:21:13 +1000119 * for complete log sectors.
120 *
121 * In addition, the buffer may be used for a non-sector-
122 * aligned block offset, in which case an I/O of the
123 * requested size could extend beyond the end of the
124 * buffer. If the requested size is only 1 basic block it
125 * will never straddle a sector boundary, so this won't be
126 * an issue. Nor will this be a problem if the log I/O is
127 * done in basic blocks (sector size 1). But otherwise we
128 * extend the buffer by one extra log sector to ensure
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300129 * there's space to accommodate this possibility.
Alex Elder36adecf2010-04-13 15:21:13 +1000130 */
Alex Elder69ce58f2010-04-20 17:09:59 +1000131 if (nbblks > 1 && log->l_sectBBsize > 1)
132 nbblks += log->l_sectBBsize;
133 nbblks = round_up(nbblks, log->l_sectBBsize);
Alex Elder36adecf2010-04-13 15:21:13 +1000134
Dave Chinnere70b73f2012-04-23 15:58:49 +1000135 bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, nbblks, 0);
Christoph Hellwigc8da0fa2011-07-08 14:36:25 +0200136 if (bp)
137 xfs_buf_unlock(bp);
138 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139}
140
Eric Sandeen5d77c0d2009-11-19 15:52:00 +0000141STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142xlog_put_bp(
143 xfs_buf_t *bp)
144{
145 xfs_buf_free(bp);
146}
147
Alex Elder48389ef2010-04-20 17:10:21 +1000148/*
149 * Return the address of the start of the given block number's data
150 * in a log buffer. The buffer covers a log sector-aligned region.
151 */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100152STATIC xfs_caddr_t
153xlog_align(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500154 struct xlog *log,
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100155 xfs_daddr_t blk_no,
156 int nbblks,
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500157 struct xfs_buf *bp)
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100158{
Christoph Hellwigfdc07f42010-05-10 17:28:14 +0000159 xfs_daddr_t offset = blk_no & ((xfs_daddr_t)log->l_sectBBsize - 1);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100160
Dave Chinner4e94b712012-04-23 15:58:51 +1000161 ASSERT(offset + nbblks <= bp->b_length);
Chandra Seetharaman62926042011-07-22 23:40:15 +0000162 return bp->b_addr + BBTOB(offset);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100163}
164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166/*
167 * nbblks should be uint, but oh well. Just want to catch that 32-bit length.
168 */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100169STATIC int
170xlog_bread_noalign(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500171 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 xfs_daddr_t blk_no,
173 int nbblks,
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500174 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175{
176 int error;
177
Alex Elderff30a622010-04-13 15:22:58 +1000178 if (!xlog_buf_bbcount_valid(log, nbblks)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100179 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
Alex Elderff30a622010-04-13 15:22:58 +1000180 nbblks);
181 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
Dave Chinner32281492009-01-22 15:37:47 +1100182 return EFSCORRUPTED;
183 }
184
Alex Elder69ce58f2010-04-20 17:09:59 +1000185 blk_no = round_down(blk_no, log->l_sectBBsize);
186 nbblks = round_up(nbblks, log->l_sectBBsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188 ASSERT(nbblks > 0);
Dave Chinner4e94b712012-04-23 15:58:51 +1000189 ASSERT(nbblks <= bp->b_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191 XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
192 XFS_BUF_READ(bp);
Dave Chinneraa0e8832012-04-23 15:58:52 +1000193 bp->b_io_length = nbblks;
Dave Chinner0e95f192012-04-23 15:58:46 +1000194 bp->b_error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Christoph Hellwig83a0adc2013-12-17 00:03:52 -0800196 if (XFS_FORCED_SHUTDOWN(log->l_mp))
197 return XFS_ERROR(EIO);
198
199 xfs_buf_iorequest(bp);
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +0000200 error = xfs_buf_iowait(bp);
David Chinnerd64e31a2008-04-10 12:22:17 +1000201 if (error)
Christoph Hellwig901796a2011-10-10 16:52:49 +0000202 xfs_buf_ioerror_alert(bp, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 return error;
204}
205
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100206STATIC int
207xlog_bread(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500208 struct xlog *log,
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100209 xfs_daddr_t blk_no,
210 int nbblks,
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500211 struct xfs_buf *bp,
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100212 xfs_caddr_t *offset)
213{
214 int error;
215
216 error = xlog_bread_noalign(log, blk_no, nbblks, bp);
217 if (error)
218 return error;
219
220 *offset = xlog_align(log, blk_no, nbblks, bp);
221 return 0;
222}
223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224/*
Dave Chinner44396472011-04-21 09:34:27 +0000225 * Read at an offset into the buffer. Returns with the buffer in it's original
226 * state regardless of the result of the read.
227 */
228STATIC int
229xlog_bread_offset(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500230 struct xlog *log,
Dave Chinner44396472011-04-21 09:34:27 +0000231 xfs_daddr_t blk_no, /* block to read from */
232 int nbblks, /* blocks to read */
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500233 struct xfs_buf *bp,
Dave Chinner44396472011-04-21 09:34:27 +0000234 xfs_caddr_t offset)
235{
Chandra Seetharaman62926042011-07-22 23:40:15 +0000236 xfs_caddr_t orig_offset = bp->b_addr;
Dave Chinner4e94b712012-04-23 15:58:51 +1000237 int orig_len = BBTOB(bp->b_length);
Dave Chinner44396472011-04-21 09:34:27 +0000238 int error, error2;
239
Chandra Seetharaman02fe03d2011-07-22 23:40:22 +0000240 error = xfs_buf_associate_memory(bp, offset, BBTOB(nbblks));
Dave Chinner44396472011-04-21 09:34:27 +0000241 if (error)
242 return error;
243
244 error = xlog_bread_noalign(log, blk_no, nbblks, bp);
245
246 /* must reset buffer pointer even on error */
Chandra Seetharaman02fe03d2011-07-22 23:40:22 +0000247 error2 = xfs_buf_associate_memory(bp, orig_offset, orig_len);
Dave Chinner44396472011-04-21 09:34:27 +0000248 if (error)
249 return error;
250 return error2;
251}
252
253/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 * Write out the buffer at the given block for the given number of blocks.
255 * The buffer is kept locked across the write and is returned locked.
256 * This can only be used for synchronous log writes.
257 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000258STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259xlog_bwrite(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500260 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 xfs_daddr_t blk_no,
262 int nbblks,
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500263 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264{
265 int error;
266
Alex Elderff30a622010-04-13 15:22:58 +1000267 if (!xlog_buf_bbcount_valid(log, nbblks)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100268 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
Alex Elderff30a622010-04-13 15:22:58 +1000269 nbblks);
270 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
Dave Chinner32281492009-01-22 15:37:47 +1100271 return EFSCORRUPTED;
272 }
273
Alex Elder69ce58f2010-04-20 17:09:59 +1000274 blk_no = round_down(blk_no, log->l_sectBBsize);
275 nbblks = round_up(nbblks, log->l_sectBBsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
277 ASSERT(nbblks > 0);
Dave Chinner4e94b712012-04-23 15:58:51 +1000278 ASSERT(nbblks <= bp->b_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
280 XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
281 XFS_BUF_ZEROFLAGS(bp);
Chandra Seetharaman72790aa2011-07-22 23:40:04 +0000282 xfs_buf_hold(bp);
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200283 xfs_buf_lock(bp);
Dave Chinneraa0e8832012-04-23 15:58:52 +1000284 bp->b_io_length = nbblks;
Dave Chinner0e95f192012-04-23 15:58:46 +1000285 bp->b_error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
Christoph Hellwigc2b006c2011-08-23 08:28:07 +0000287 error = xfs_bwrite(bp);
Christoph Hellwig901796a2011-10-10 16:52:49 +0000288 if (error)
289 xfs_buf_ioerror_alert(bp, __func__);
Christoph Hellwigc2b006c2011-08-23 08:28:07 +0000290 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 return error;
292}
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294#ifdef DEBUG
295/*
296 * dump debug superblock and log record information
297 */
298STATIC void
299xlog_header_check_dump(
300 xfs_mount_t *mp,
301 xlog_rec_header_t *head)
302{
Eric Sandeen08e96e12013-10-11 20:59:05 -0500303 xfs_debug(mp, "%s: SB : uuid = %pU, fmt = %d",
Joe Perches03daa572009-12-14 18:01:10 -0800304 __func__, &mp->m_sb.sb_uuid, XLOG_FMT);
Eric Sandeen08e96e12013-10-11 20:59:05 -0500305 xfs_debug(mp, " log : uuid = %pU, fmt = %d",
Joe Perches03daa572009-12-14 18:01:10 -0800306 &head->h_fs_uuid, be32_to_cpu(head->h_fmt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307}
308#else
309#define xlog_header_check_dump(mp, head)
310#endif
311
312/*
313 * check log record header for recovery
314 */
315STATIC int
316xlog_header_check_recover(
317 xfs_mount_t *mp,
318 xlog_rec_header_t *head)
319{
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200320 ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
322 /*
323 * IRIX doesn't write the h_fmt field and leaves it zeroed
324 * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
325 * a dirty log created in IRIX.
326 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200327 if (unlikely(head->h_fmt != cpu_to_be32(XLOG_FMT))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100328 xfs_warn(mp,
329 "dirty log written in incompatible format - can't recover");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 xlog_header_check_dump(mp, head);
331 XFS_ERROR_REPORT("xlog_header_check_recover(1)",
332 XFS_ERRLEVEL_HIGH, mp);
333 return XFS_ERROR(EFSCORRUPTED);
334 } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100335 xfs_warn(mp,
336 "dirty log entry has mismatched uuid - can't recover");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 xlog_header_check_dump(mp, head);
338 XFS_ERROR_REPORT("xlog_header_check_recover(2)",
339 XFS_ERRLEVEL_HIGH, mp);
340 return XFS_ERROR(EFSCORRUPTED);
341 }
342 return 0;
343}
344
345/*
346 * read the head block of the log and check the header
347 */
348STATIC int
349xlog_header_check_mount(
350 xfs_mount_t *mp,
351 xlog_rec_header_t *head)
352{
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200353 ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
355 if (uuid_is_nil(&head->h_fs_uuid)) {
356 /*
357 * IRIX doesn't write the h_fs_uuid or h_fmt fields. If
358 * h_fs_uuid is nil, we assume this log was last mounted
359 * by IRIX and continue.
360 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100361 xfs_warn(mp, "nil uuid in log - IRIX style log");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100363 xfs_warn(mp, "log has mismatched uuid - can't recover");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 xlog_header_check_dump(mp, head);
365 XFS_ERROR_REPORT("xlog_header_check_mount",
366 XFS_ERRLEVEL_HIGH, mp);
367 return XFS_ERROR(EFSCORRUPTED);
368 }
369 return 0;
370}
371
372STATIC void
373xlog_recover_iodone(
374 struct xfs_buf *bp)
375{
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +0000376 if (bp->b_error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 /*
378 * We're not going to bother about retrying
379 * this during recovery. One strike!
380 */
Christoph Hellwig901796a2011-10-10 16:52:49 +0000381 xfs_buf_ioerror_alert(bp, __func__);
Dave Chinnerebad8612010-09-22 10:47:20 +1000382 xfs_force_shutdown(bp->b_target->bt_mount,
383 SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 }
Christoph Hellwigcb669ca2011-07-13 13:43:49 +0200385 bp->b_iodone = NULL;
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +0000386 xfs_buf_ioend(bp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387}
388
389/*
390 * This routine finds (to an approximation) the first block in the physical
391 * log which contains the given cycle. It uses a binary search algorithm.
392 * Note that the algorithm can not be perfect because the disk will not
393 * necessarily be perfect.
394 */
David Chinnera8272ce2007-11-23 16:28:09 +1100395STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396xlog_find_cycle_start(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500397 struct xlog *log,
398 struct xfs_buf *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 xfs_daddr_t first_blk,
400 xfs_daddr_t *last_blk,
401 uint cycle)
402{
403 xfs_caddr_t offset;
404 xfs_daddr_t mid_blk;
Alex Eldere3bb2e32010-04-15 18:17:30 +0000405 xfs_daddr_t end_blk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 uint mid_cycle;
407 int error;
408
Alex Eldere3bb2e32010-04-15 18:17:30 +0000409 end_blk = *last_blk;
410 mid_blk = BLK_AVG(first_blk, end_blk);
411 while (mid_blk != first_blk && mid_blk != end_blk) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100412 error = xlog_bread(log, mid_blk, 1, bp, &offset);
413 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 return error;
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000415 mid_cycle = xlog_get_cycle(offset);
Alex Eldere3bb2e32010-04-15 18:17:30 +0000416 if (mid_cycle == cycle)
417 end_blk = mid_blk; /* last_half_cycle == mid_cycle */
418 else
419 first_blk = mid_blk; /* first_half_cycle == mid_cycle */
420 mid_blk = BLK_AVG(first_blk, end_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 }
Alex Eldere3bb2e32010-04-15 18:17:30 +0000422 ASSERT((mid_blk == first_blk && mid_blk+1 == end_blk) ||
423 (mid_blk == end_blk && mid_blk-1 == first_blk));
424
425 *last_blk = end_blk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
427 return 0;
428}
429
430/*
Alex Elder3f943d82010-04-15 18:17:34 +0000431 * Check that a range of blocks does not contain stop_on_cycle_no.
432 * Fill in *new_blk with the block offset where such a block is
433 * found, or with -1 (an invalid block number) if there is no such
434 * block in the range. The scan needs to occur from front to back
435 * and the pointer into the region must be updated since a later
436 * routine will need to perform another test.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 */
438STATIC int
439xlog_find_verify_cycle(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500440 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 xfs_daddr_t start_blk,
442 int nbblks,
443 uint stop_on_cycle_no,
444 xfs_daddr_t *new_blk)
445{
446 xfs_daddr_t i, j;
447 uint cycle;
448 xfs_buf_t *bp;
449 xfs_daddr_t bufblks;
450 xfs_caddr_t buf = NULL;
451 int error = 0;
452
Alex Elder6881a222010-04-13 15:22:29 +1000453 /*
454 * Greedily allocate a buffer big enough to handle the full
455 * range of basic blocks we'll be examining. If that fails,
456 * try a smaller size. We need to be able to read at least
457 * a log sector, or we're out of luck.
458 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 bufblks = 1 << ffs(nbblks);
Dave Chinner81158e02012-04-27 19:45:22 +1000460 while (bufblks > log->l_logBBsize)
461 bufblks >>= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 while (!(bp = xlog_get_bp(log, bufblks))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 bufblks >>= 1;
Alex Elder69ce58f2010-04-20 17:09:59 +1000464 if (bufblks < log->l_sectBBsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 return ENOMEM;
466 }
467
468 for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
469 int bcount;
470
471 bcount = min(bufblks, (start_blk + nbblks - i));
472
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100473 error = xlog_bread(log, i, bcount, bp, &buf);
474 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 goto out;
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 for (j = 0; j < bcount; j++) {
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000478 cycle = xlog_get_cycle(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 if (cycle == stop_on_cycle_no) {
480 *new_blk = i+j;
481 goto out;
482 }
483
484 buf += BBSIZE;
485 }
486 }
487
488 *new_blk = -1;
489
490out:
491 xlog_put_bp(bp);
492 return error;
493}
494
495/*
496 * Potentially backup over partial log record write.
497 *
498 * In the typical case, last_blk is the number of the block directly after
499 * a good log record. Therefore, we subtract one to get the block number
500 * of the last block in the given buffer. extra_bblks contains the number
501 * of blocks we would have read on a previous read. This happens when the
502 * last log record is split over the end of the physical log.
503 *
504 * extra_bblks is the number of blocks potentially verified on a previous
505 * call to this routine.
506 */
507STATIC int
508xlog_find_verify_log_record(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500509 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 xfs_daddr_t start_blk,
511 xfs_daddr_t *last_blk,
512 int extra_bblks)
513{
514 xfs_daddr_t i;
515 xfs_buf_t *bp;
516 xfs_caddr_t offset = NULL;
517 xlog_rec_header_t *head = NULL;
518 int error = 0;
519 int smallmem = 0;
520 int num_blks = *last_blk - start_blk;
521 int xhdrs;
522
523 ASSERT(start_blk != 0 || *last_blk != start_blk);
524
525 if (!(bp = xlog_get_bp(log, num_blks))) {
526 if (!(bp = xlog_get_bp(log, 1)))
527 return ENOMEM;
528 smallmem = 1;
529 } else {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100530 error = xlog_bread(log, start_blk, num_blks, bp, &offset);
531 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 offset += ((num_blks - 1) << BBSHIFT);
534 }
535
536 for (i = (*last_blk) - 1; i >= 0; i--) {
537 if (i < start_blk) {
538 /* valid log record not found */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100539 xfs_warn(log->l_mp,
540 "Log inconsistent (didn't find previous header)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 ASSERT(0);
542 error = XFS_ERROR(EIO);
543 goto out;
544 }
545
546 if (smallmem) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100547 error = xlog_bread(log, i, 1, bp, &offset);
548 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 }
551
552 head = (xlog_rec_header_t *)offset;
553
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200554 if (head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 break;
556
557 if (!smallmem)
558 offset -= BBSIZE;
559 }
560
561 /*
562 * We hit the beginning of the physical log & still no header. Return
563 * to caller. If caller can handle a return of -1, then this routine
564 * will be called again for the end of the physical log.
565 */
566 if (i == -1) {
567 error = -1;
568 goto out;
569 }
570
571 /*
572 * We have the final block of the good log (the first block
573 * of the log record _before_ the head. So we check the uuid.
574 */
575 if ((error = xlog_header_check_mount(log->l_mp, head)))
576 goto out;
577
578 /*
579 * We may have found a log record header before we expected one.
580 * last_blk will be the 1st block # with a given cycle #. We may end
581 * up reading an entire log record. In this case, we don't want to
582 * reset last_blk. Only when last_blk points in the middle of a log
583 * record do we update last_blk.
584 */
Eric Sandeen62118702008-03-06 13:44:28 +1100585 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000586 uint h_size = be32_to_cpu(head->h_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
589 if (h_size % XLOG_HEADER_CYCLE_SIZE)
590 xhdrs++;
591 } else {
592 xhdrs = 1;
593 }
594
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000595 if (*last_blk - i + extra_bblks !=
596 BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 *last_blk = i;
598
599out:
600 xlog_put_bp(bp);
601 return error;
602}
603
604/*
605 * Head is defined to be the point of the log where the next log write
Zhi Yong Wu0a94da22013-08-07 10:11:08 +0000606 * could go. This means that incomplete LR writes at the end are
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 * eliminated when calculating the head. We aren't guaranteed that previous
608 * LR have complete transactions. We only know that a cycle number of
609 * current cycle number -1 won't be present in the log if we start writing
610 * from our current block number.
611 *
612 * last_blk contains the block number of the first block with a given
613 * cycle number.
614 *
615 * Return: zero if normal, non-zero if error.
616 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000617STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618xlog_find_head(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500619 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 xfs_daddr_t *return_head_blk)
621{
622 xfs_buf_t *bp;
623 xfs_caddr_t offset;
624 xfs_daddr_t new_blk, first_blk, start_blk, last_blk, head_blk;
625 int num_scan_bblks;
626 uint first_half_cycle, last_half_cycle;
627 uint stop_on_cycle;
628 int error, log_bbnum = log->l_logBBsize;
629
630 /* Is the end of the log device zeroed? */
631 if ((error = xlog_find_zeroed(log, &first_blk)) == -1) {
632 *return_head_blk = first_blk;
633
634 /* Is the whole lot zeroed? */
635 if (!first_blk) {
636 /* Linux XFS shouldn't generate totally zeroed logs -
637 * mkfs etc write a dummy unmount record to a fresh
638 * log so we can store the uuid in there
639 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100640 xfs_warn(log->l_mp, "totally zeroed log");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 }
642
643 return 0;
644 } else if (error) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100645 xfs_warn(log->l_mp, "empty log check failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 return error;
647 }
648
649 first_blk = 0; /* get cycle # of 1st block */
650 bp = xlog_get_bp(log, 1);
651 if (!bp)
652 return ENOMEM;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100653
654 error = xlog_bread(log, 0, 1, bp, &offset);
655 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100657
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000658 first_half_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
660 last_blk = head_blk = log_bbnum - 1; /* get cycle # of last block */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100661 error = xlog_bread(log, last_blk, 1, bp, &offset);
662 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100664
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000665 last_half_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 ASSERT(last_half_cycle != 0);
667
668 /*
669 * If the 1st half cycle number is equal to the last half cycle number,
670 * then the entire log is stamped with the same cycle number. In this
671 * case, head_blk can't be set to zero (which makes sense). The below
672 * math doesn't work out properly with head_blk equal to zero. Instead,
673 * we set it to log_bbnum which is an invalid block number, but this
674 * value makes the math correct. If head_blk doesn't changed through
675 * all the tests below, *head_blk is set to zero at the very end rather
676 * than log_bbnum. In a sense, log_bbnum and zero are the same block
677 * in a circular file.
678 */
679 if (first_half_cycle == last_half_cycle) {
680 /*
681 * In this case we believe that the entire log should have
682 * cycle number last_half_cycle. We need to scan backwards
683 * from the end verifying that there are no holes still
684 * containing last_half_cycle - 1. If we find such a hole,
685 * then the start of that hole will be the new head. The
686 * simple case looks like
687 * x | x ... | x - 1 | x
688 * Another case that fits this picture would be
689 * x | x + 1 | x ... | x
Nathan Scottc41564b2006-03-29 08:55:14 +1000690 * In this case the head really is somewhere at the end of the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 * log, as one of the latest writes at the beginning was
692 * incomplete.
693 * One more case is
694 * x | x + 1 | x ... | x - 1 | x
695 * This is really the combination of the above two cases, and
696 * the head has to end up at the start of the x-1 hole at the
697 * end of the log.
698 *
699 * In the 256k log case, we will read from the beginning to the
700 * end of the log and search for cycle numbers equal to x-1.
701 * We don't worry about the x+1 blocks that we encounter,
702 * because we know that they cannot be the head since the log
703 * started with x.
704 */
705 head_blk = log_bbnum;
706 stop_on_cycle = last_half_cycle - 1;
707 } else {
708 /*
709 * In this case we want to find the first block with cycle
710 * number matching last_half_cycle. We expect the log to be
711 * some variation on
Alex Elder3f943d82010-04-15 18:17:34 +0000712 * x + 1 ... | x ... | x
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 * The first block with cycle number x (last_half_cycle) will
714 * be where the new head belongs. First we do a binary search
715 * for the first occurrence of last_half_cycle. The binary
716 * search may not be totally accurate, so then we scan back
717 * from there looking for occurrences of last_half_cycle before
718 * us. If that backwards scan wraps around the beginning of
719 * the log, then we look for occurrences of last_half_cycle - 1
720 * at the end of the log. The cases we're looking for look
721 * like
Alex Elder3f943d82010-04-15 18:17:34 +0000722 * v binary search stopped here
723 * x + 1 ... | x | x + 1 | x ... | x
724 * ^ but we want to locate this spot
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 * or
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 * <---------> less than scan distance
Alex Elder3f943d82010-04-15 18:17:34 +0000727 * x + 1 ... | x ... | x - 1 | x
728 * ^ we want to locate this spot
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 */
730 stop_on_cycle = last_half_cycle;
731 if ((error = xlog_find_cycle_start(log, bp, first_blk,
732 &head_blk, last_half_cycle)))
733 goto bp_err;
734 }
735
736 /*
737 * Now validate the answer. Scan back some number of maximum possible
738 * blocks and make sure each one has the expected cycle number. The
739 * maximum is determined by the total possible amount of buffering
740 * in the in-core log. The following number can be made tighter if
741 * we actually look at the block size of the filesystem.
742 */
743 num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
744 if (head_blk >= num_scan_bblks) {
745 /*
746 * We are guaranteed that the entire check can be performed
747 * in one buffer.
748 */
749 start_blk = head_blk - num_scan_bblks;
750 if ((error = xlog_find_verify_cycle(log,
751 start_blk, num_scan_bblks,
752 stop_on_cycle, &new_blk)))
753 goto bp_err;
754 if (new_blk != -1)
755 head_blk = new_blk;
756 } else { /* need to read 2 parts of log */
757 /*
758 * We are going to scan backwards in the log in two parts.
759 * First we scan the physical end of the log. In this part
760 * of the log, we are looking for blocks with cycle number
761 * last_half_cycle - 1.
762 * If we find one, then we know that the log starts there, as
763 * we've found a hole that didn't get written in going around
764 * the end of the physical log. The simple case for this is
765 * x + 1 ... | x ... | x - 1 | x
766 * <---------> less than scan distance
767 * If all of the blocks at the end of the log have cycle number
768 * last_half_cycle, then we check the blocks at the start of
769 * the log looking for occurrences of last_half_cycle. If we
770 * find one, then our current estimate for the location of the
771 * first occurrence of last_half_cycle is wrong and we move
772 * back to the hole we've found. This case looks like
773 * x + 1 ... | x | x + 1 | x ...
774 * ^ binary search stopped here
775 * Another case we need to handle that only occurs in 256k
776 * logs is
777 * x + 1 ... | x ... | x+1 | x ...
778 * ^ binary search stops here
779 * In a 256k log, the scan at the end of the log will see the
780 * x + 1 blocks. We need to skip past those since that is
781 * certainly not the head of the log. By searching for
782 * last_half_cycle-1 we accomplish that.
783 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 ASSERT(head_blk <= INT_MAX &&
Alex Elder3f943d82010-04-15 18:17:34 +0000785 (xfs_daddr_t) num_scan_bblks >= head_blk);
786 start_blk = log_bbnum - (num_scan_bblks - head_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 if ((error = xlog_find_verify_cycle(log, start_blk,
788 num_scan_bblks - (int)head_blk,
789 (stop_on_cycle - 1), &new_blk)))
790 goto bp_err;
791 if (new_blk != -1) {
792 head_blk = new_blk;
Alex Elder9db127e2010-04-15 18:17:26 +0000793 goto validate_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 }
795
796 /*
797 * Scan beginning of log now. The last part of the physical
798 * log is good. This scan needs to verify that it doesn't find
799 * the last_half_cycle.
800 */
801 start_blk = 0;
802 ASSERT(head_blk <= INT_MAX);
803 if ((error = xlog_find_verify_cycle(log,
804 start_blk, (int)head_blk,
805 stop_on_cycle, &new_blk)))
806 goto bp_err;
807 if (new_blk != -1)
808 head_blk = new_blk;
809 }
810
Alex Elder9db127e2010-04-15 18:17:26 +0000811validate_head:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 /*
813 * Now we need to make sure head_blk is not pointing to a block in
814 * the middle of a log record.
815 */
816 num_scan_bblks = XLOG_REC_SHIFT(log);
817 if (head_blk >= num_scan_bblks) {
818 start_blk = head_blk - num_scan_bblks; /* don't read head_blk */
819
820 /* start ptr at last block ptr before head_blk */
821 if ((error = xlog_find_verify_log_record(log, start_blk,
822 &head_blk, 0)) == -1) {
823 error = XFS_ERROR(EIO);
824 goto bp_err;
825 } else if (error)
826 goto bp_err;
827 } else {
828 start_blk = 0;
829 ASSERT(head_blk <= INT_MAX);
830 if ((error = xlog_find_verify_log_record(log, start_blk,
831 &head_blk, 0)) == -1) {
832 /* We hit the beginning of the log during our search */
Alex Elder3f943d82010-04-15 18:17:34 +0000833 start_blk = log_bbnum - (num_scan_bblks - head_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 new_blk = log_bbnum;
835 ASSERT(start_blk <= INT_MAX &&
836 (xfs_daddr_t) log_bbnum-start_blk >= 0);
837 ASSERT(head_blk <= INT_MAX);
838 if ((error = xlog_find_verify_log_record(log,
839 start_blk, &new_blk,
840 (int)head_blk)) == -1) {
841 error = XFS_ERROR(EIO);
842 goto bp_err;
843 } else if (error)
844 goto bp_err;
845 if (new_blk != log_bbnum)
846 head_blk = new_blk;
847 } else if (error)
848 goto bp_err;
849 }
850
851 xlog_put_bp(bp);
852 if (head_blk == log_bbnum)
853 *return_head_blk = 0;
854 else
855 *return_head_blk = head_blk;
856 /*
857 * When returning here, we have a good block number. Bad block
858 * means that during a previous crash, we didn't have a clean break
859 * from cycle number N to cycle number N-1. In this case, we need
860 * to find the first block with cycle number N-1.
861 */
862 return 0;
863
864 bp_err:
865 xlog_put_bp(bp);
866
867 if (error)
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100868 xfs_warn(log->l_mp, "failed to find log head");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 return error;
870}
871
872/*
873 * Find the sync block number or the tail of the log.
874 *
875 * This will be the block number of the last record to have its
876 * associated buffers synced to disk. Every log record header has
877 * a sync lsn embedded in it. LSNs hold block numbers, so it is easy
878 * to get a sync block number. The only concern is to figure out which
879 * log record header to believe.
880 *
881 * The following algorithm uses the log record header with the largest
882 * lsn. The entire log record does not need to be valid. We only care
883 * that the header is valid.
884 *
885 * We could speed up search by using current head_blk buffer, but it is not
886 * available.
887 */
Eric Sandeen5d77c0d2009-11-19 15:52:00 +0000888STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889xlog_find_tail(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500890 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 xfs_daddr_t *head_blk,
Eric Sandeen65be6052006-01-11 15:34:19 +1100892 xfs_daddr_t *tail_blk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893{
894 xlog_rec_header_t *rhead;
895 xlog_op_header_t *op_head;
896 xfs_caddr_t offset = NULL;
897 xfs_buf_t *bp;
898 int error, i, found;
899 xfs_daddr_t umount_data_blk;
900 xfs_daddr_t after_umount_blk;
901 xfs_lsn_t tail_lsn;
902 int hblks;
903
904 found = 0;
905
906 /*
907 * Find previous log record
908 */
909 if ((error = xlog_find_head(log, head_blk)))
910 return error;
911
912 bp = xlog_get_bp(log, 1);
913 if (!bp)
914 return ENOMEM;
915 if (*head_blk == 0) { /* special case */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100916 error = xlog_bread(log, 0, 1, bp, &offset);
917 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +0000918 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100919
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000920 if (xlog_get_cycle(offset) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 *tail_blk = 0;
922 /* leave all other log inited values alone */
Alex Elder9db127e2010-04-15 18:17:26 +0000923 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 }
925 }
926
927 /*
928 * Search backwards looking for log record header block
929 */
930 ASSERT(*head_blk < INT_MAX);
931 for (i = (int)(*head_blk) - 1; i >= 0; i--) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100932 error = xlog_bread(log, i, 1, bp, &offset);
933 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +0000934 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100935
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200936 if (*(__be32 *)offset == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 found = 1;
938 break;
939 }
940 }
941 /*
942 * If we haven't found the log record header block, start looking
943 * again from the end of the physical log. XXXmiken: There should be
944 * a check here to make sure we didn't search more than N blocks in
945 * the previous code.
946 */
947 if (!found) {
948 for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100949 error = xlog_bread(log, i, 1, bp, &offset);
950 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +0000951 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100952
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200953 if (*(__be32 *)offset ==
954 cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 found = 2;
956 break;
957 }
958 }
959 }
960 if (!found) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100961 xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__);
Eric Sandeen050a1952013-07-31 20:33:47 -0500962 xlog_put_bp(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 ASSERT(0);
964 return XFS_ERROR(EIO);
965 }
966
967 /* find blk_no of tail of log */
968 rhead = (xlog_rec_header_t *)offset;
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000969 *tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970
971 /*
972 * Reset log values according to the state of the log when we
973 * crashed. In the case where head_blk == 0, we bump curr_cycle
974 * one because the next write starts a new cycle rather than
975 * continuing the cycle of the last good log record. At this
976 * point we have guaranteed that all partial log records have been
977 * accounted for. Therefore, we know that the last good log record
978 * written was complete and ended exactly on the end boundary
979 * of the physical log.
980 */
981 log->l_prev_block = i;
982 log->l_curr_block = (int)*head_blk;
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000983 log->l_curr_cycle = be32_to_cpu(rhead->h_cycle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 if (found == 2)
985 log->l_curr_cycle++;
Dave Chinner1c3cb9e2010-12-21 12:28:39 +1100986 atomic64_set(&log->l_tail_lsn, be64_to_cpu(rhead->h_tail_lsn));
Dave Chinner84f3c682010-12-03 22:11:29 +1100987 atomic64_set(&log->l_last_sync_lsn, be64_to_cpu(rhead->h_lsn));
Christoph Hellwig28496962012-02-20 02:31:25 +0000988 xlog_assign_grant_head(&log->l_reserve_head.grant, log->l_curr_cycle,
Dave Chinnera69ed032010-12-21 12:08:20 +1100989 BBTOB(log->l_curr_block));
Christoph Hellwig28496962012-02-20 02:31:25 +0000990 xlog_assign_grant_head(&log->l_write_head.grant, log->l_curr_cycle,
Dave Chinnera69ed032010-12-21 12:08:20 +1100991 BBTOB(log->l_curr_block));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
993 /*
994 * Look for unmount record. If we find it, then we know there
995 * was a clean unmount. Since 'i' could be the last block in
996 * the physical log, we convert to a log block before comparing
997 * to the head_blk.
998 *
999 * Save the current tail lsn to use to pass to
1000 * xlog_clear_stale_blocks() below. We won't want to clear the
1001 * unmount record if there is one, so we pass the lsn of the
1002 * unmount record rather than the block after it.
1003 */
Eric Sandeen62118702008-03-06 13:44:28 +11001004 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001005 int h_size = be32_to_cpu(rhead->h_size);
1006 int h_version = be32_to_cpu(rhead->h_version);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
1008 if ((h_version & XLOG_VERSION_2) &&
1009 (h_size > XLOG_HEADER_CYCLE_SIZE)) {
1010 hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
1011 if (h_size % XLOG_HEADER_CYCLE_SIZE)
1012 hblks++;
1013 } else {
1014 hblks = 1;
1015 }
1016 } else {
1017 hblks = 1;
1018 }
1019 after_umount_blk = (i + hblks + (int)
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001020 BTOBB(be32_to_cpu(rhead->h_len))) % log->l_logBBsize;
Dave Chinner1c3cb9e2010-12-21 12:28:39 +11001021 tail_lsn = atomic64_read(&log->l_tail_lsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 if (*head_blk == after_umount_blk &&
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001023 be32_to_cpu(rhead->h_num_logops) == 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 umount_data_blk = (i + hblks) % log->l_logBBsize;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001025 error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
1026 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +00001027 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001028
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 op_head = (xlog_op_header_t *)offset;
1030 if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
1031 /*
1032 * Set tail and last sync so that newly written
1033 * log records will point recovery to after the
1034 * current unmount record.
1035 */
Dave Chinner1c3cb9e2010-12-21 12:28:39 +11001036 xlog_assign_atomic_lsn(&log->l_tail_lsn,
1037 log->l_curr_cycle, after_umount_blk);
1038 xlog_assign_atomic_lsn(&log->l_last_sync_lsn,
1039 log->l_curr_cycle, after_umount_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 *tail_blk = after_umount_blk;
David Chinner92821e22007-05-24 15:26:31 +10001041
1042 /*
1043 * Note that the unmount was clean. If the unmount
1044 * was not clean, we need to know this to rebuild the
1045 * superblock counters from the perag headers if we
1046 * have a filesystem using non-persistent counters.
1047 */
1048 log->l_mp->m_flags |= XFS_MOUNT_WAS_CLEAN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 }
1050 }
1051
1052 /*
1053 * Make sure that there are no blocks in front of the head
1054 * with the same cycle number as the head. This can happen
1055 * because we allow multiple outstanding log writes concurrently,
1056 * and the later writes might make it out before earlier ones.
1057 *
1058 * We use the lsn from before modifying it so that we'll never
1059 * overwrite the unmount record after a clean unmount.
1060 *
1061 * Do this only if we are going to recover the filesystem
1062 *
1063 * NOTE: This used to say "if (!readonly)"
1064 * However on Linux, we can & do recover a read-only filesystem.
1065 * We only skip recovery if NORECOVERY is specified on mount,
1066 * in which case we would not be here.
1067 *
1068 * But... if the -device- itself is readonly, just skip this.
1069 * We can't recover this device anyway, so it won't matter.
1070 */
Alex Elder9db127e2010-04-15 18:17:26 +00001071 if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 error = xlog_clear_stale_blocks(log, tail_lsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
Alex Elder9db127e2010-04-15 18:17:26 +00001074done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 xlog_put_bp(bp);
1076
1077 if (error)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001078 xfs_warn(log->l_mp, "failed to locate log tail");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 return error;
1080}
1081
1082/*
1083 * Is the log zeroed at all?
1084 *
1085 * The last binary search should be changed to perform an X block read
1086 * once X becomes small enough. You can then search linearly through
1087 * the X blocks. This will cut down on the number of reads we need to do.
1088 *
1089 * If the log is partially zeroed, this routine will pass back the blkno
1090 * of the first block with cycle number 0. It won't have a complete LR
1091 * preceding it.
1092 *
1093 * Return:
1094 * 0 => the log is completely written to
1095 * -1 => use *blk_no as the first block of the log
1096 * >0 => error has occurred
1097 */
David Chinnera8272ce2007-11-23 16:28:09 +11001098STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099xlog_find_zeroed(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05001100 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 xfs_daddr_t *blk_no)
1102{
1103 xfs_buf_t *bp;
1104 xfs_caddr_t offset;
1105 uint first_cycle, last_cycle;
1106 xfs_daddr_t new_blk, last_blk, start_blk;
1107 xfs_daddr_t num_scan_bblks;
1108 int error, log_bbnum = log->l_logBBsize;
1109
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10001110 *blk_no = 0;
1111
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 /* check totally zeroed log */
1113 bp = xlog_get_bp(log, 1);
1114 if (!bp)
1115 return ENOMEM;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001116 error = xlog_bread(log, 0, 1, bp, &offset);
1117 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001119
Christoph Hellwig03bea6f2007-10-12 10:58:05 +10001120 first_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 if (first_cycle == 0) { /* completely zeroed log */
1122 *blk_no = 0;
1123 xlog_put_bp(bp);
1124 return -1;
1125 }
1126
1127 /* check partially zeroed log */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001128 error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
1129 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001131
Christoph Hellwig03bea6f2007-10-12 10:58:05 +10001132 last_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 if (last_cycle != 0) { /* log completely written to */
1134 xlog_put_bp(bp);
1135 return 0;
1136 } else if (first_cycle != 1) {
1137 /*
1138 * If the cycle of the last block is zero, the cycle of
1139 * the first block must be 1. If it's not, maybe we're
1140 * not looking at a log... Bail out.
1141 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001142 xfs_warn(log->l_mp,
1143 "Log inconsistent or not a log (last==0, first!=1)");
Eric Sandeen5d0a6542013-07-31 20:32:30 -05001144 error = XFS_ERROR(EINVAL);
1145 goto bp_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 }
1147
1148 /* we have a partially zeroed log */
1149 last_blk = log_bbnum-1;
1150 if ((error = xlog_find_cycle_start(log, bp, 0, &last_blk, 0)))
1151 goto bp_err;
1152
1153 /*
1154 * Validate the answer. Because there is no way to guarantee that
1155 * the entire log is made up of log records which are the same size,
1156 * we scan over the defined maximum blocks. At this point, the maximum
1157 * is not chosen to mean anything special. XXXmiken
1158 */
1159 num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
1160 ASSERT(num_scan_bblks <= INT_MAX);
1161
1162 if (last_blk < num_scan_bblks)
1163 num_scan_bblks = last_blk;
1164 start_blk = last_blk - num_scan_bblks;
1165
1166 /*
1167 * We search for any instances of cycle number 0 that occur before
1168 * our current estimate of the head. What we're trying to detect is
1169 * 1 ... | 0 | 1 | 0...
1170 * ^ binary search ends here
1171 */
1172 if ((error = xlog_find_verify_cycle(log, start_blk,
1173 (int)num_scan_bblks, 0, &new_blk)))
1174 goto bp_err;
1175 if (new_blk != -1)
1176 last_blk = new_blk;
1177
1178 /*
1179 * Potentially backup over partial log record write. We don't need
1180 * to search the end of the log because we know it is zero.
1181 */
1182 if ((error = xlog_find_verify_log_record(log, start_blk,
1183 &last_blk, 0)) == -1) {
1184 error = XFS_ERROR(EIO);
1185 goto bp_err;
1186 } else if (error)
1187 goto bp_err;
1188
1189 *blk_no = last_blk;
1190bp_err:
1191 xlog_put_bp(bp);
1192 if (error)
1193 return error;
1194 return -1;
1195}
1196
1197/*
1198 * These are simple subroutines used by xlog_clear_stale_blocks() below
1199 * to initialize a buffer full of empty log record headers and write
1200 * them into the log.
1201 */
1202STATIC void
1203xlog_add_record(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05001204 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 xfs_caddr_t buf,
1206 int cycle,
1207 int block,
1208 int tail_cycle,
1209 int tail_block)
1210{
1211 xlog_rec_header_t *recp = (xlog_rec_header_t *)buf;
1212
1213 memset(buf, 0, BBSIZE);
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001214 recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
1215 recp->h_cycle = cpu_to_be32(cycle);
1216 recp->h_version = cpu_to_be32(
Eric Sandeen62118702008-03-06 13:44:28 +11001217 xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001218 recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block));
1219 recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block));
1220 recp->h_fmt = cpu_to_be32(XLOG_FMT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
1222}
1223
1224STATIC int
1225xlog_write_log_records(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05001226 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 int cycle,
1228 int start_block,
1229 int blocks,
1230 int tail_cycle,
1231 int tail_block)
1232{
1233 xfs_caddr_t offset;
1234 xfs_buf_t *bp;
1235 int balign, ealign;
Alex Elder69ce58f2010-04-20 17:09:59 +10001236 int sectbb = log->l_sectBBsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 int end_block = start_block + blocks;
1238 int bufblks;
1239 int error = 0;
1240 int i, j = 0;
1241
Alex Elder6881a222010-04-13 15:22:29 +10001242 /*
1243 * Greedily allocate a buffer big enough to handle the full
1244 * range of basic blocks to be written. If that fails, try
1245 * a smaller size. We need to be able to write at least a
1246 * log sector, or we're out of luck.
1247 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 bufblks = 1 << ffs(blocks);
Dave Chinner81158e02012-04-27 19:45:22 +10001249 while (bufblks > log->l_logBBsize)
1250 bufblks >>= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 while (!(bp = xlog_get_bp(log, bufblks))) {
1252 bufblks >>= 1;
Alex Elder69ce58f2010-04-20 17:09:59 +10001253 if (bufblks < sectbb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 return ENOMEM;
1255 }
1256
1257 /* We may need to do a read at the start to fill in part of
1258 * the buffer in the starting sector not covered by the first
1259 * write below.
1260 */
Alex Elder5c17f532010-04-13 15:22:48 +10001261 balign = round_down(start_block, sectbb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 if (balign != start_block) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001263 error = xlog_bread_noalign(log, start_block, 1, bp);
1264 if (error)
1265 goto out_put_bp;
1266
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 j = start_block - balign;
1268 }
1269
1270 for (i = start_block; i < end_block; i += bufblks) {
1271 int bcount, endcount;
1272
1273 bcount = min(bufblks, end_block - start_block);
1274 endcount = bcount - j;
1275
1276 /* We may need to do a read at the end to fill in part of
1277 * the buffer in the final sector not covered by the write.
1278 * If this is the same sector as the above read, skip it.
1279 */
Alex Elder5c17f532010-04-13 15:22:48 +10001280 ealign = round_down(end_block, sectbb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 if (j == 0 && (start_block + endcount > ealign)) {
Chandra Seetharaman62926042011-07-22 23:40:15 +00001282 offset = bp->b_addr + BBTOB(ealign - start_block);
Dave Chinner44396472011-04-21 09:34:27 +00001283 error = xlog_bread_offset(log, ealign, sectbb,
1284 bp, offset);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001285 if (error)
1286 break;
1287
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 }
1289
1290 offset = xlog_align(log, start_block, endcount, bp);
1291 for (; j < endcount; j++) {
1292 xlog_add_record(log, offset, cycle, i+j,
1293 tail_cycle, tail_block);
1294 offset += BBSIZE;
1295 }
1296 error = xlog_bwrite(log, start_block, endcount, bp);
1297 if (error)
1298 break;
1299 start_block += endcount;
1300 j = 0;
1301 }
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001302
1303 out_put_bp:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 xlog_put_bp(bp);
1305 return error;
1306}
1307
1308/*
1309 * This routine is called to blow away any incomplete log writes out
1310 * in front of the log head. We do this so that we won't become confused
1311 * if we come up, write only a little bit more, and then crash again.
1312 * If we leave the partial log records out there, this situation could
1313 * cause us to think those partial writes are valid blocks since they
1314 * have the current cycle number. We get rid of them by overwriting them
1315 * with empty log records with the old cycle number rather than the
1316 * current one.
1317 *
1318 * The tail lsn is passed in rather than taken from
1319 * the log so that we will not write over the unmount record after a
1320 * clean unmount in a 512 block log. Doing so would leave the log without
1321 * any valid log records in it until a new one was written. If we crashed
1322 * during that time we would not be able to recover.
1323 */
1324STATIC int
1325xlog_clear_stale_blocks(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05001326 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 xfs_lsn_t tail_lsn)
1328{
1329 int tail_cycle, head_cycle;
1330 int tail_block, head_block;
1331 int tail_distance, max_distance;
1332 int distance;
1333 int error;
1334
1335 tail_cycle = CYCLE_LSN(tail_lsn);
1336 tail_block = BLOCK_LSN(tail_lsn);
1337 head_cycle = log->l_curr_cycle;
1338 head_block = log->l_curr_block;
1339
1340 /*
1341 * Figure out the distance between the new head of the log
1342 * and the tail. We want to write over any blocks beyond the
1343 * head that we may have written just before the crash, but
1344 * we don't want to overwrite the tail of the log.
1345 */
1346 if (head_cycle == tail_cycle) {
1347 /*
1348 * The tail is behind the head in the physical log,
1349 * so the distance from the head to the tail is the
1350 * distance from the head to the end of the log plus
1351 * the distance from the beginning of the log to the
1352 * tail.
1353 */
1354 if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
1355 XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
1356 XFS_ERRLEVEL_LOW, log->l_mp);
1357 return XFS_ERROR(EFSCORRUPTED);
1358 }
1359 tail_distance = tail_block + (log->l_logBBsize - head_block);
1360 } else {
1361 /*
1362 * The head is behind the tail in the physical log,
1363 * so the distance from the head to the tail is just
1364 * the tail block minus the head block.
1365 */
1366 if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
1367 XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
1368 XFS_ERRLEVEL_LOW, log->l_mp);
1369 return XFS_ERROR(EFSCORRUPTED);
1370 }
1371 tail_distance = tail_block - head_block;
1372 }
1373
1374 /*
1375 * If the head is right up against the tail, we can't clear
1376 * anything.
1377 */
1378 if (tail_distance <= 0) {
1379 ASSERT(tail_distance == 0);
1380 return 0;
1381 }
1382
1383 max_distance = XLOG_TOTAL_REC_SHIFT(log);
1384 /*
1385 * Take the smaller of the maximum amount of outstanding I/O
1386 * we could have and the distance to the tail to clear out.
1387 * We take the smaller so that we don't overwrite the tail and
1388 * we don't waste all day writing from the head to the tail
1389 * for no reason.
1390 */
1391 max_distance = MIN(max_distance, tail_distance);
1392
1393 if ((head_block + max_distance) <= log->l_logBBsize) {
1394 /*
1395 * We can stomp all the blocks we need to without
1396 * wrapping around the end of the log. Just do it
1397 * in a single write. Use the cycle number of the
1398 * current cycle minus one so that the log will look like:
1399 * n ... | n - 1 ...
1400 */
1401 error = xlog_write_log_records(log, (head_cycle - 1),
1402 head_block, max_distance, tail_cycle,
1403 tail_block);
1404 if (error)
1405 return error;
1406 } else {
1407 /*
1408 * We need to wrap around the end of the physical log in
1409 * order to clear all the blocks. Do it in two separate
1410 * I/Os. The first write should be from the head to the
1411 * end of the physical log, and it should use the current
1412 * cycle number minus one just like above.
1413 */
1414 distance = log->l_logBBsize - head_block;
1415 error = xlog_write_log_records(log, (head_cycle - 1),
1416 head_block, distance, tail_cycle,
1417 tail_block);
1418
1419 if (error)
1420 return error;
1421
1422 /*
1423 * Now write the blocks at the start of the physical log.
1424 * This writes the remainder of the blocks we want to clear.
1425 * It uses the current cycle number since we're now on the
1426 * same cycle as the head so that we get:
1427 * n ... n ... | n - 1 ...
1428 * ^^^^^ blocks we're writing
1429 */
1430 distance = max_distance - (log->l_logBBsize - head_block);
1431 error = xlog_write_log_records(log, head_cycle, 0, distance,
1432 tail_cycle, tail_block);
1433 if (error)
1434 return error;
1435 }
1436
1437 return 0;
1438}
1439
1440/******************************************************************************
1441 *
1442 * Log recover routines
1443 *
1444 ******************************************************************************
1445 */
1446
1447STATIC xlog_recover_t *
1448xlog_recover_find_tid(
Dave Chinnerf0a76952010-01-11 11:49:57 +00001449 struct hlist_head *head,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 xlog_tid_t tid)
1451{
Dave Chinnerf0a76952010-01-11 11:49:57 +00001452 xlog_recover_t *trans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453
Sasha Levinb67bfe02013-02-27 17:06:00 -08001454 hlist_for_each_entry(trans, head, r_list) {
Dave Chinnerf0a76952010-01-11 11:49:57 +00001455 if (trans->r_log_tid == tid)
1456 return trans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 }
Dave Chinnerf0a76952010-01-11 11:49:57 +00001458 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459}
1460
1461STATIC void
Dave Chinnerf0a76952010-01-11 11:49:57 +00001462xlog_recover_new_tid(
1463 struct hlist_head *head,
1464 xlog_tid_t tid,
1465 xfs_lsn_t lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466{
Dave Chinnerf0a76952010-01-11 11:49:57 +00001467 xlog_recover_t *trans;
1468
1469 trans = kmem_zalloc(sizeof(xlog_recover_t), KM_SLEEP);
1470 trans->r_log_tid = tid;
1471 trans->r_lsn = lsn;
1472 INIT_LIST_HEAD(&trans->r_itemq);
1473
1474 INIT_HLIST_NODE(&trans->r_list);
1475 hlist_add_head(&trans->r_list, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476}
1477
1478STATIC void
1479xlog_recover_add_item(
Dave Chinnerf0a76952010-01-11 11:49:57 +00001480 struct list_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481{
1482 xlog_recover_item_t *item;
1483
1484 item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
Dave Chinnerf0a76952010-01-11 11:49:57 +00001485 INIT_LIST_HEAD(&item->ri_list);
1486 list_add_tail(&item->ri_list, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487}
1488
1489STATIC int
1490xlog_recover_add_to_cont_trans(
Mark Tinguelyad223e62012-06-14 09:22:15 -05001491 struct xlog *log,
1492 struct xlog_recover *trans,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 xfs_caddr_t dp,
1494 int len)
1495{
1496 xlog_recover_item_t *item;
1497 xfs_caddr_t ptr, old_ptr;
1498 int old_len;
1499
Dave Chinnerf0a76952010-01-11 11:49:57 +00001500 if (list_empty(&trans->r_itemq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 /* finish copying rest of trans header */
1502 xlog_recover_add_item(&trans->r_itemq);
1503 ptr = (xfs_caddr_t) &trans->r_theader +
1504 sizeof(xfs_trans_header_t) - len;
1505 memcpy(ptr, dp, len); /* d, s, l */
1506 return 0;
1507 }
Dave Chinnerf0a76952010-01-11 11:49:57 +00001508 /* take the tail entry */
1509 item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510
1511 old_ptr = item->ri_buf[item->ri_cnt-1].i_addr;
1512 old_len = item->ri_buf[item->ri_cnt-1].i_len;
1513
Mitsuo Hayasaka45053602012-01-27 06:37:26 +00001514 ptr = kmem_realloc(old_ptr, len+old_len, old_len, KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 memcpy(&ptr[old_len], dp, len); /* d, s, l */
1516 item->ri_buf[item->ri_cnt-1].i_len += len;
1517 item->ri_buf[item->ri_cnt-1].i_addr = ptr;
Dave Chinner9abbc532010-04-13 15:06:46 +10001518 trace_xfs_log_recover_item_add_cont(log, trans, item, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 return 0;
1520}
1521
1522/*
1523 * The next region to add is the start of a new region. It could be
1524 * a whole region or it could be the first part of a new region. Because
1525 * of this, the assumption here is that the type and size fields of all
1526 * format structures fit into the first 32 bits of the structure.
1527 *
1528 * This works because all regions must be 32 bit aligned. Therefore, we
1529 * either have both fields or we have neither field. In the case we have
1530 * neither field, the data part of the region is zero length. We only have
1531 * a log_op_header and can throw away the header since a new one will appear
1532 * later. If we have at least 4 bytes, then we can determine how many regions
1533 * will appear in the current log item.
1534 */
1535STATIC int
1536xlog_recover_add_to_trans(
Mark Tinguelyad223e62012-06-14 09:22:15 -05001537 struct xlog *log,
1538 struct xlog_recover *trans,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 xfs_caddr_t dp,
1540 int len)
1541{
1542 xfs_inode_log_format_t *in_f; /* any will do */
1543 xlog_recover_item_t *item;
1544 xfs_caddr_t ptr;
1545
1546 if (!len)
1547 return 0;
Dave Chinnerf0a76952010-01-11 11:49:57 +00001548 if (list_empty(&trans->r_itemq)) {
David Chinner5a792c42008-10-30 17:40:09 +11001549 /* we need to catch log corruptions here */
1550 if (*(uint *)dp != XFS_TRANS_HEADER_MAGIC) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001551 xfs_warn(log->l_mp, "%s: bad header magic number",
1552 __func__);
David Chinner5a792c42008-10-30 17:40:09 +11001553 ASSERT(0);
1554 return XFS_ERROR(EIO);
1555 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 if (len == sizeof(xfs_trans_header_t))
1557 xlog_recover_add_item(&trans->r_itemq);
1558 memcpy(&trans->r_theader, dp, len); /* d, s, l */
1559 return 0;
1560 }
1561
1562 ptr = kmem_alloc(len, KM_SLEEP);
1563 memcpy(ptr, dp, len);
1564 in_f = (xfs_inode_log_format_t *)ptr;
1565
Dave Chinnerf0a76952010-01-11 11:49:57 +00001566 /* take the tail entry */
1567 item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
1568 if (item->ri_total != 0 &&
1569 item->ri_total == item->ri_cnt) {
1570 /* tail item is in use, get a new one */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 xlog_recover_add_item(&trans->r_itemq);
Dave Chinnerf0a76952010-01-11 11:49:57 +00001572 item = list_entry(trans->r_itemq.prev,
1573 xlog_recover_item_t, ri_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
1576 if (item->ri_total == 0) { /* first region to be added */
Christoph Hellwige8fa6b42009-03-03 14:48:36 -05001577 if (in_f->ilf_size == 0 ||
1578 in_f->ilf_size > XLOG_MAX_REGIONS_IN_ITEM) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001579 xfs_warn(log->l_mp,
1580 "bad number of regions (%d) in inode log format",
Christoph Hellwige8fa6b42009-03-03 14:48:36 -05001581 in_f->ilf_size);
1582 ASSERT(0);
Thierry Redingaaaae982013-10-01 16:47:53 +02001583 kmem_free(ptr);
Christoph Hellwige8fa6b42009-03-03 14:48:36 -05001584 return XFS_ERROR(EIO);
1585 }
1586
1587 item->ri_total = in_f->ilf_size;
1588 item->ri_buf =
1589 kmem_zalloc(item->ri_total * sizeof(xfs_log_iovec_t),
1590 KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 }
1592 ASSERT(item->ri_total > item->ri_cnt);
1593 /* Description region is ri_buf[0] */
1594 item->ri_buf[item->ri_cnt].i_addr = ptr;
1595 item->ri_buf[item->ri_cnt].i_len = len;
1596 item->ri_cnt++;
Dave Chinner9abbc532010-04-13 15:06:46 +10001597 trace_xfs_log_recover_item_add(log, trans, item, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 return 0;
1599}
1600
Dave Chinnerf0a76952010-01-11 11:49:57 +00001601/*
Dave Chinnera775ad72013-06-05 12:09:07 +10001602 * Sort the log items in the transaction.
1603 *
1604 * The ordering constraints are defined by the inode allocation and unlink
1605 * behaviour. The rules are:
1606 *
1607 * 1. Every item is only logged once in a given transaction. Hence it
1608 * represents the last logged state of the item. Hence ordering is
1609 * dependent on the order in which operations need to be performed so
1610 * required initial conditions are always met.
1611 *
1612 * 2. Cancelled buffers are recorded in pass 1 in a separate table and
1613 * there's nothing to replay from them so we can simply cull them
1614 * from the transaction. However, we can't do that until after we've
1615 * replayed all the other items because they may be dependent on the
1616 * cancelled buffer and replaying the cancelled buffer can remove it
1617 * form the cancelled buffer table. Hence they have tobe done last.
1618 *
1619 * 3. Inode allocation buffers must be replayed before inode items that
Dave Chinner28c8e412013-06-27 16:04:55 +10001620 * read the buffer and replay changes into it. For filesystems using the
1621 * ICREATE transactions, this means XFS_LI_ICREATE objects need to get
1622 * treated the same as inode allocation buffers as they create and
1623 * initialise the buffers directly.
Dave Chinnera775ad72013-06-05 12:09:07 +10001624 *
1625 * 4. Inode unlink buffers must be replayed after inode items are replayed.
1626 * This ensures that inodes are completely flushed to the inode buffer
1627 * in a "free" state before we remove the unlinked inode list pointer.
1628 *
1629 * Hence the ordering needs to be inode allocation buffers first, inode items
1630 * second, inode unlink buffers third and cancelled buffers last.
1631 *
1632 * But there's a problem with that - we can't tell an inode allocation buffer
1633 * apart from a regular buffer, so we can't separate them. We can, however,
1634 * tell an inode unlink buffer from the others, and so we can separate them out
1635 * from all the other buffers and move them to last.
1636 *
1637 * Hence, 4 lists, in order from head to tail:
Dave Chinner28c8e412013-06-27 16:04:55 +10001638 * - buffer_list for all buffers except cancelled/inode unlink buffers
1639 * - item_list for all non-buffer items
1640 * - inode_buffer_list for inode unlink buffers
1641 * - cancel_list for the cancelled buffers
1642 *
1643 * Note that we add objects to the tail of the lists so that first-to-last
1644 * ordering is preserved within the lists. Adding objects to the head of the
1645 * list means when we traverse from the head we walk them in last-to-first
1646 * order. For cancelled buffers and inode unlink buffers this doesn't matter,
1647 * but for all other items there may be specific ordering that we need to
1648 * preserve.
Dave Chinnerf0a76952010-01-11 11:49:57 +00001649 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650STATIC int
1651xlog_recover_reorder_trans(
Mark Tinguelyad223e62012-06-14 09:22:15 -05001652 struct xlog *log,
1653 struct xlog_recover *trans,
Dave Chinner9abbc532010-04-13 15:06:46 +10001654 int pass)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655{
Dave Chinnerf0a76952010-01-11 11:49:57 +00001656 xlog_recover_item_t *item, *n;
Mark Tinguely2a841082013-10-02 07:51:12 -05001657 int error = 0;
Dave Chinnerf0a76952010-01-11 11:49:57 +00001658 LIST_HEAD(sort_list);
Dave Chinnera775ad72013-06-05 12:09:07 +10001659 LIST_HEAD(cancel_list);
1660 LIST_HEAD(buffer_list);
1661 LIST_HEAD(inode_buffer_list);
1662 LIST_HEAD(inode_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
Dave Chinnerf0a76952010-01-11 11:49:57 +00001664 list_splice_init(&trans->r_itemq, &sort_list);
1665 list_for_each_entry_safe(item, n, &sort_list, ri_list) {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10001666 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
Dave Chinnerf0a76952010-01-11 11:49:57 +00001667
1668 switch (ITEM_TYPE(item)) {
Dave Chinner28c8e412013-06-27 16:04:55 +10001669 case XFS_LI_ICREATE:
1670 list_move_tail(&item->ri_list, &buffer_list);
1671 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 case XFS_LI_BUF:
Dave Chinnera775ad72013-06-05 12:09:07 +10001673 if (buf_f->blf_flags & XFS_BLF_CANCEL) {
Dave Chinner9abbc532010-04-13 15:06:46 +10001674 trace_xfs_log_recover_item_reorder_head(log,
1675 trans, item, pass);
Dave Chinnera775ad72013-06-05 12:09:07 +10001676 list_move(&item->ri_list, &cancel_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 break;
1678 }
Dave Chinnera775ad72013-06-05 12:09:07 +10001679 if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
1680 list_move(&item->ri_list, &inode_buffer_list);
1681 break;
1682 }
1683 list_move_tail(&item->ri_list, &buffer_list);
1684 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 case XFS_LI_INODE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 case XFS_LI_DQUOT:
1687 case XFS_LI_QUOTAOFF:
1688 case XFS_LI_EFD:
1689 case XFS_LI_EFI:
Dave Chinner9abbc532010-04-13 15:06:46 +10001690 trace_xfs_log_recover_item_reorder_tail(log,
1691 trans, item, pass);
Dave Chinnera775ad72013-06-05 12:09:07 +10001692 list_move_tail(&item->ri_list, &inode_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 break;
1694 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001695 xfs_warn(log->l_mp,
1696 "%s: unrecognized type of log operation",
1697 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 ASSERT(0);
Mark Tinguely2a841082013-10-02 07:51:12 -05001699 /*
1700 * return the remaining items back to the transaction
1701 * item list so they can be freed in caller.
1702 */
1703 if (!list_empty(&sort_list))
1704 list_splice_init(&sort_list, &trans->r_itemq);
1705 error = XFS_ERROR(EIO);
1706 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 }
Dave Chinnerf0a76952010-01-11 11:49:57 +00001708 }
Mark Tinguely2a841082013-10-02 07:51:12 -05001709out:
Dave Chinnerf0a76952010-01-11 11:49:57 +00001710 ASSERT(list_empty(&sort_list));
Dave Chinnera775ad72013-06-05 12:09:07 +10001711 if (!list_empty(&buffer_list))
1712 list_splice(&buffer_list, &trans->r_itemq);
1713 if (!list_empty(&inode_list))
1714 list_splice_tail(&inode_list, &trans->r_itemq);
1715 if (!list_empty(&inode_buffer_list))
1716 list_splice_tail(&inode_buffer_list, &trans->r_itemq);
1717 if (!list_empty(&cancel_list))
1718 list_splice_tail(&cancel_list, &trans->r_itemq);
Mark Tinguely2a841082013-10-02 07:51:12 -05001719 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720}
1721
1722/*
1723 * Build up the table of buf cancel records so that we don't replay
1724 * cancelled data in the second pass. For buffer records that are
1725 * not cancel records, there is nothing to do here so we just return.
1726 *
1727 * If we get a cancel record which is already in the table, this indicates
1728 * that the buffer was cancelled multiple times. In order to ensure
1729 * that during pass 2 we keep the record in the table until we reach its
1730 * last occurrence in the log, we keep a reference count in the cancel
1731 * record in the table to tell us how many times we expect to see this
1732 * record during the second pass.
1733 */
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001734STATIC int
1735xlog_recover_buffer_pass1(
Mark Tinguelyad223e62012-06-14 09:22:15 -05001736 struct xlog *log,
1737 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001739 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001740 struct list_head *bucket;
1741 struct xfs_buf_cancel *bcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742
1743 /*
1744 * If this isn't a cancel buffer item, then just return.
1745 */
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001746 if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
Dave Chinner9abbc532010-04-13 15:06:46 +10001747 trace_xfs_log_recover_buf_not_cancel(log, buf_f);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001748 return 0;
Dave Chinner9abbc532010-04-13 15:06:46 +10001749 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750
1751 /*
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001752 * Insert an xfs_buf_cancel record into the hash table of them.
1753 * If there is already an identical record, bump its reference count.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 */
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001755 bucket = XLOG_BUF_CANCEL_BUCKET(log, buf_f->blf_blkno);
1756 list_for_each_entry(bcp, bucket, bc_list) {
1757 if (bcp->bc_blkno == buf_f->blf_blkno &&
1758 bcp->bc_len == buf_f->blf_len) {
1759 bcp->bc_refcount++;
Dave Chinner9abbc532010-04-13 15:06:46 +10001760 trace_xfs_log_recover_buf_cancel_ref_inc(log, buf_f);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001761 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 }
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001764
1765 bcp = kmem_alloc(sizeof(struct xfs_buf_cancel), KM_SLEEP);
1766 bcp->bc_blkno = buf_f->blf_blkno;
1767 bcp->bc_len = buf_f->blf_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 bcp->bc_refcount = 1;
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001769 list_add_tail(&bcp->bc_list, bucket);
1770
Dave Chinner9abbc532010-04-13 15:06:46 +10001771 trace_xfs_log_recover_buf_cancel_add(log, buf_f);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001772 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773}
1774
1775/*
1776 * Check to see whether the buffer being recovered has a corresponding
Dave Chinner84a5b732013-08-27 08:10:53 +10001777 * entry in the buffer cancel record table. If it is, return the cancel
1778 * buffer structure to the caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 */
Dave Chinner84a5b732013-08-27 08:10:53 +10001780STATIC struct xfs_buf_cancel *
1781xlog_peek_buffer_cancelled(
Mark Tinguelyad223e62012-06-14 09:22:15 -05001782 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 xfs_daddr_t blkno,
1784 uint len,
1785 ushort flags)
1786{
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001787 struct list_head *bucket;
1788 struct xfs_buf_cancel *bcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
Dave Chinner84a5b732013-08-27 08:10:53 +10001790 if (!log->l_buf_cancel_table) {
1791 /* empty table means no cancelled buffers in the log */
Dave Chinnerc1155412010-05-07 11:05:19 +10001792 ASSERT(!(flags & XFS_BLF_CANCEL));
Dave Chinner84a5b732013-08-27 08:10:53 +10001793 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 }
1795
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001796 bucket = XLOG_BUF_CANCEL_BUCKET(log, blkno);
1797 list_for_each_entry(bcp, bucket, bc_list) {
1798 if (bcp->bc_blkno == blkno && bcp->bc_len == len)
Dave Chinner84a5b732013-08-27 08:10:53 +10001799 return bcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 }
1801
1802 /*
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001803 * We didn't find a corresponding entry in the table, so return 0 so
1804 * that the buffer is NOT cancelled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 */
Dave Chinnerc1155412010-05-07 11:05:19 +10001806 ASSERT(!(flags & XFS_BLF_CANCEL));
Dave Chinner84a5b732013-08-27 08:10:53 +10001807 return NULL;
1808}
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001809
Dave Chinner84a5b732013-08-27 08:10:53 +10001810/*
1811 * If the buffer is being cancelled then return 1 so that it will be cancelled,
1812 * otherwise return 0. If the buffer is actually a buffer cancel item
1813 * (XFS_BLF_CANCEL is set), then decrement the refcount on the entry in the
1814 * table and remove it from the table if this is the last reference.
1815 *
1816 * We remove the cancel record from the table when we encounter its last
1817 * occurrence in the log so that if the same buffer is re-used again after its
1818 * last cancellation we actually replay the changes made at that point.
1819 */
1820STATIC int
1821xlog_check_buffer_cancelled(
1822 struct xlog *log,
1823 xfs_daddr_t blkno,
1824 uint len,
1825 ushort flags)
1826{
1827 struct xfs_buf_cancel *bcp;
1828
1829 bcp = xlog_peek_buffer_cancelled(log, blkno, len, flags);
1830 if (!bcp)
1831 return 0;
1832
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001833 /*
1834 * We've go a match, so return 1 so that the recovery of this buffer
1835 * is cancelled. If this buffer is actually a buffer cancel log
1836 * item, then decrement the refcount on the one in the table and
1837 * remove it if this is the last reference.
1838 */
1839 if (flags & XFS_BLF_CANCEL) {
1840 if (--bcp->bc_refcount == 0) {
1841 list_del(&bcp->bc_list);
1842 kmem_free(bcp);
1843 }
1844 }
1845 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846}
1847
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848/*
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001849 * Perform recovery for a buffer full of inodes. In these buffers, the only
1850 * data which should be recovered is that which corresponds to the
1851 * di_next_unlinked pointers in the on disk inode structures. The rest of the
1852 * data for the inodes is always logged through the inodes themselves rather
1853 * than the inode buffer and is recovered in xlog_recover_inode_pass2().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 *
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001855 * The only time when buffers full of inodes are fully recovered is when the
1856 * buffer is full of newly allocated inodes. In this case the buffer will
1857 * not be marked as an inode buffer and so will be sent to
1858 * xlog_recover_do_reg_buffer() below during recovery.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 */
1860STATIC int
1861xlog_recover_do_inode_buffer(
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001862 struct xfs_mount *mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 xlog_recover_item_t *item,
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001864 struct xfs_buf *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 xfs_buf_log_format_t *buf_f)
1866{
1867 int i;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001868 int item_index = 0;
1869 int bit = 0;
1870 int nbits = 0;
1871 int reg_buf_offset = 0;
1872 int reg_buf_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 int next_unlinked_offset;
1874 int inodes_per_buf;
1875 xfs_agino_t *logged_nextp;
1876 xfs_agino_t *buffer_nextp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877
Dave Chinner9abbc532010-04-13 15:06:46 +10001878 trace_xfs_log_recover_buf_inode_buf(mp->m_log, buf_f);
Dave Chinner9222a9c2013-06-12 12:19:06 +10001879
1880 /*
1881 * Post recovery validation only works properly on CRC enabled
1882 * filesystems.
1883 */
1884 if (xfs_sb_version_hascrc(&mp->m_sb))
1885 bp->b_ops = &xfs_inode_buf_ops;
Dave Chinner9abbc532010-04-13 15:06:46 +10001886
Dave Chinneraa0e8832012-04-23 15:58:52 +10001887 inodes_per_buf = BBTOB(bp->b_io_length) >> mp->m_sb.sb_inodelog;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 for (i = 0; i < inodes_per_buf; i++) {
1889 next_unlinked_offset = (i * mp->m_sb.sb_inodesize) +
1890 offsetof(xfs_dinode_t, di_next_unlinked);
1891
1892 while (next_unlinked_offset >=
1893 (reg_buf_offset + reg_buf_bytes)) {
1894 /*
1895 * The next di_next_unlinked field is beyond
1896 * the current logged region. Find the next
1897 * logged region that contains or is beyond
1898 * the current di_next_unlinked field.
1899 */
1900 bit += nbits;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001901 bit = xfs_next_bit(buf_f->blf_data_map,
1902 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903
1904 /*
1905 * If there are no more logged regions in the
1906 * buffer, then we're done.
1907 */
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001908 if (bit == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001911 nbits = xfs_contig_bits(buf_f->blf_data_map,
1912 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 ASSERT(nbits > 0);
Dave Chinnerc1155412010-05-07 11:05:19 +10001914 reg_buf_offset = bit << XFS_BLF_SHIFT;
1915 reg_buf_bytes = nbits << XFS_BLF_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 item_index++;
1917 }
1918
1919 /*
1920 * If the current logged region starts after the current
1921 * di_next_unlinked field, then move on to the next
1922 * di_next_unlinked field.
1923 */
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001924 if (next_unlinked_offset < reg_buf_offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926
1927 ASSERT(item->ri_buf[item_index].i_addr != NULL);
Dave Chinnerc1155412010-05-07 11:05:19 +10001928 ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0);
Dave Chinneraa0e8832012-04-23 15:58:52 +10001929 ASSERT((reg_buf_offset + reg_buf_bytes) <=
1930 BBTOB(bp->b_io_length));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931
1932 /*
1933 * The current logged region contains a copy of the
1934 * current di_next_unlinked field. Extract its value
1935 * and copy it to the buffer copy.
1936 */
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10001937 logged_nextp = item->ri_buf[item_index].i_addr +
1938 next_unlinked_offset - reg_buf_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 if (unlikely(*logged_nextp == 0)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001940 xfs_alert(mp,
1941 "Bad inode buffer log record (ptr = 0x%p, bp = 0x%p). "
1942 "Trying to replay bad (0) inode di_next_unlinked field.",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 item, bp);
1944 XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
1945 XFS_ERRLEVEL_LOW, mp);
1946 return XFS_ERROR(EFSCORRUPTED);
1947 }
1948
1949 buffer_nextp = (xfs_agino_t *)xfs_buf_offset(bp,
1950 next_unlinked_offset);
Tim Shimmin87c199c2006-06-09 14:56:16 +10001951 *buffer_nextp = *logged_nextp;
Dave Chinner0a32c262013-06-05 12:09:08 +10001952
1953 /*
1954 * If necessary, recalculate the CRC in the on-disk inode. We
1955 * have to leave the inode in a consistent state for whoever
1956 * reads it next....
1957 */
1958 xfs_dinode_calc_crc(mp, (struct xfs_dinode *)
1959 xfs_buf_offset(bp, i * mp->m_sb.sb_inodesize));
1960
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 }
1962
1963 return 0;
1964}
1965
1966/*
Dave Chinner50d5c8d2013-08-28 21:22:47 +10001967 * V5 filesystems know the age of the buffer on disk being recovered. We can
1968 * have newer objects on disk than we are replaying, and so for these cases we
1969 * don't want to replay the current change as that will make the buffer contents
1970 * temporarily invalid on disk.
1971 *
1972 * The magic number might not match the buffer type we are going to recover
1973 * (e.g. reallocated blocks), so we ignore the xfs_buf_log_format flags. Hence
1974 * extract the LSN of the existing object in the buffer based on it's current
1975 * magic number. If we don't recognise the magic number in the buffer, then
1976 * return a LSN of -1 so that the caller knows it was an unrecognised block and
1977 * so can recover the buffer.
Dave Chinner566055d2013-09-24 16:01:16 +10001978 *
1979 * Note: we cannot rely solely on magic number matches to determine that the
1980 * buffer has a valid LSN - we also need to verify that it belongs to this
1981 * filesystem, so we need to extract the object's LSN and compare it to that
1982 * which we read from the superblock. If the UUIDs don't match, then we've got a
1983 * stale metadata block from an old filesystem instance that we need to recover
1984 * over the top of.
Dave Chinner50d5c8d2013-08-28 21:22:47 +10001985 */
1986static xfs_lsn_t
1987xlog_recover_get_buf_lsn(
1988 struct xfs_mount *mp,
1989 struct xfs_buf *bp)
1990{
1991 __uint32_t magic32;
1992 __uint16_t magic16;
1993 __uint16_t magicda;
1994 void *blk = bp->b_addr;
Dave Chinner566055d2013-09-24 16:01:16 +10001995 uuid_t *uuid;
1996 xfs_lsn_t lsn = -1;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10001997
1998 /* v4 filesystems always recover immediately */
1999 if (!xfs_sb_version_hascrc(&mp->m_sb))
2000 goto recover_immediately;
2001
2002 magic32 = be32_to_cpu(*(__be32 *)blk);
2003 switch (magic32) {
2004 case XFS_ABTB_CRC_MAGIC:
2005 case XFS_ABTC_CRC_MAGIC:
2006 case XFS_ABTB_MAGIC:
2007 case XFS_ABTC_MAGIC:
2008 case XFS_IBT_CRC_MAGIC:
Dave Chinner566055d2013-09-24 16:01:16 +10002009 case XFS_IBT_MAGIC: {
2010 struct xfs_btree_block *btb = blk;
2011
2012 lsn = be64_to_cpu(btb->bb_u.s.bb_lsn);
2013 uuid = &btb->bb_u.s.bb_uuid;
2014 break;
2015 }
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002016 case XFS_BMAP_CRC_MAGIC:
Dave Chinner566055d2013-09-24 16:01:16 +10002017 case XFS_BMAP_MAGIC: {
2018 struct xfs_btree_block *btb = blk;
2019
2020 lsn = be64_to_cpu(btb->bb_u.l.bb_lsn);
2021 uuid = &btb->bb_u.l.bb_uuid;
2022 break;
2023 }
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002024 case XFS_AGF_MAGIC:
Dave Chinner566055d2013-09-24 16:01:16 +10002025 lsn = be64_to_cpu(((struct xfs_agf *)blk)->agf_lsn);
2026 uuid = &((struct xfs_agf *)blk)->agf_uuid;
2027 break;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002028 case XFS_AGFL_MAGIC:
Dave Chinner566055d2013-09-24 16:01:16 +10002029 lsn = be64_to_cpu(((struct xfs_agfl *)blk)->agfl_lsn);
2030 uuid = &((struct xfs_agfl *)blk)->agfl_uuid;
2031 break;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002032 case XFS_AGI_MAGIC:
Dave Chinner566055d2013-09-24 16:01:16 +10002033 lsn = be64_to_cpu(((struct xfs_agi *)blk)->agi_lsn);
2034 uuid = &((struct xfs_agi *)blk)->agi_uuid;
2035 break;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002036 case XFS_SYMLINK_MAGIC:
Dave Chinner566055d2013-09-24 16:01:16 +10002037 lsn = be64_to_cpu(((struct xfs_dsymlink_hdr *)blk)->sl_lsn);
2038 uuid = &((struct xfs_dsymlink_hdr *)blk)->sl_uuid;
2039 break;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002040 case XFS_DIR3_BLOCK_MAGIC:
2041 case XFS_DIR3_DATA_MAGIC:
2042 case XFS_DIR3_FREE_MAGIC:
Dave Chinner566055d2013-09-24 16:01:16 +10002043 lsn = be64_to_cpu(((struct xfs_dir3_blk_hdr *)blk)->lsn);
2044 uuid = &((struct xfs_dir3_blk_hdr *)blk)->uuid;
2045 break;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002046 case XFS_ATTR3_RMT_MAGIC:
Dave Chinner566055d2013-09-24 16:01:16 +10002047 lsn = be64_to_cpu(((struct xfs_attr3_rmt_hdr *)blk)->rm_lsn);
2048 uuid = &((struct xfs_attr3_rmt_hdr *)blk)->rm_uuid;
2049 break;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002050 case XFS_SB_MAGIC:
Dave Chinner566055d2013-09-24 16:01:16 +10002051 lsn = be64_to_cpu(((struct xfs_dsb *)blk)->sb_lsn);
2052 uuid = &((struct xfs_dsb *)blk)->sb_uuid;
2053 break;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002054 default:
2055 break;
2056 }
2057
Dave Chinner566055d2013-09-24 16:01:16 +10002058 if (lsn != (xfs_lsn_t)-1) {
2059 if (!uuid_equal(&mp->m_sb.sb_uuid, uuid))
2060 goto recover_immediately;
2061 return lsn;
2062 }
2063
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002064 magicda = be16_to_cpu(((struct xfs_da_blkinfo *)blk)->magic);
2065 switch (magicda) {
2066 case XFS_DIR3_LEAF1_MAGIC:
2067 case XFS_DIR3_LEAFN_MAGIC:
2068 case XFS_DA3_NODE_MAGIC:
Dave Chinner566055d2013-09-24 16:01:16 +10002069 lsn = be64_to_cpu(((struct xfs_da3_blkinfo *)blk)->lsn);
2070 uuid = &((struct xfs_da3_blkinfo *)blk)->uuid;
2071 break;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002072 default:
2073 break;
2074 }
2075
Dave Chinner566055d2013-09-24 16:01:16 +10002076 if (lsn != (xfs_lsn_t)-1) {
2077 if (!uuid_equal(&mp->m_sb.sb_uuid, uuid))
2078 goto recover_immediately;
2079 return lsn;
2080 }
2081
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002082 /*
2083 * We do individual object checks on dquot and inode buffers as they
2084 * have their own individual LSN records. Also, we could have a stale
2085 * buffer here, so we have to at least recognise these buffer types.
2086 *
2087 * A notd complexity here is inode unlinked list processing - it logs
2088 * the inode directly in the buffer, but we don't know which inodes have
2089 * been modified, and there is no global buffer LSN. Hence we need to
2090 * recover all inode buffer types immediately. This problem will be
2091 * fixed by logical logging of the unlinked list modifications.
2092 */
2093 magic16 = be16_to_cpu(*(__be16 *)blk);
2094 switch (magic16) {
2095 case XFS_DQUOT_MAGIC:
2096 case XFS_DINODE_MAGIC:
2097 goto recover_immediately;
2098 default:
2099 break;
2100 }
2101
2102 /* unknown buffer contents, recover immediately */
2103
2104recover_immediately:
2105 return (xfs_lsn_t)-1;
2106
2107}
2108
2109/*
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002110 * Validate the recovered buffer is of the correct type and attach the
2111 * appropriate buffer operations to them for writeback. Magic numbers are in a
2112 * few places:
2113 * the first 16 bits of the buffer (inode buffer, dquot buffer),
2114 * the first 32 bits of the buffer (most blocks),
2115 * inside a struct xfs_da_blkinfo at the start of the buffer.
2116 */
2117static void
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002118xlog_recover_validate_buf_type(
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002119 struct xfs_mount *mp,
2120 struct xfs_buf *bp,
2121 xfs_buf_log_format_t *buf_f)
2122{
2123 struct xfs_da_blkinfo *info = bp->b_addr;
2124 __uint32_t magic32;
2125 __uint16_t magic16;
2126 __uint16_t magicda;
2127
2128 magic32 = be32_to_cpu(*(__be32 *)bp->b_addr);
2129 magic16 = be16_to_cpu(*(__be16*)bp->b_addr);
2130 magicda = be16_to_cpu(info->magic);
Dave Chinner61fe1352013-04-03 16:11:30 +11002131 switch (xfs_blft_from_flags(buf_f)) {
2132 case XFS_BLFT_BTREE_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002133 switch (magic32) {
2134 case XFS_ABTB_CRC_MAGIC:
2135 case XFS_ABTC_CRC_MAGIC:
2136 case XFS_ABTB_MAGIC:
2137 case XFS_ABTC_MAGIC:
2138 bp->b_ops = &xfs_allocbt_buf_ops;
2139 break;
2140 case XFS_IBT_CRC_MAGIC:
2141 case XFS_IBT_MAGIC:
2142 bp->b_ops = &xfs_inobt_buf_ops;
2143 break;
2144 case XFS_BMAP_CRC_MAGIC:
2145 case XFS_BMAP_MAGIC:
2146 bp->b_ops = &xfs_bmbt_buf_ops;
2147 break;
2148 default:
2149 xfs_warn(mp, "Bad btree block magic!");
2150 ASSERT(0);
2151 break;
2152 }
2153 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002154 case XFS_BLFT_AGF_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002155 if (magic32 != XFS_AGF_MAGIC) {
2156 xfs_warn(mp, "Bad AGF block magic!");
2157 ASSERT(0);
2158 break;
2159 }
2160 bp->b_ops = &xfs_agf_buf_ops;
2161 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002162 case XFS_BLFT_AGFL_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002163 if (!xfs_sb_version_hascrc(&mp->m_sb))
2164 break;
2165 if (magic32 != XFS_AGFL_MAGIC) {
2166 xfs_warn(mp, "Bad AGFL block magic!");
2167 ASSERT(0);
2168 break;
2169 }
2170 bp->b_ops = &xfs_agfl_buf_ops;
2171 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002172 case XFS_BLFT_AGI_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002173 if (magic32 != XFS_AGI_MAGIC) {
2174 xfs_warn(mp, "Bad AGI block magic!");
2175 ASSERT(0);
2176 break;
2177 }
2178 bp->b_ops = &xfs_agi_buf_ops;
2179 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002180 case XFS_BLFT_UDQUOT_BUF:
2181 case XFS_BLFT_PDQUOT_BUF:
2182 case XFS_BLFT_GDQUOT_BUF:
Dave Chinner123887e2013-04-30 21:39:33 +10002183#ifdef CONFIG_XFS_QUOTA
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002184 if (magic16 != XFS_DQUOT_MAGIC) {
2185 xfs_warn(mp, "Bad DQUOT block magic!");
2186 ASSERT(0);
2187 break;
2188 }
2189 bp->b_ops = &xfs_dquot_buf_ops;
Dave Chinner123887e2013-04-30 21:39:33 +10002190#else
2191 xfs_alert(mp,
2192 "Trying to recover dquots without QUOTA support built in!");
2193 ASSERT(0);
2194#endif
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002195 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002196 case XFS_BLFT_DINO_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002197 /*
2198 * we get here with inode allocation buffers, not buffers that
2199 * track unlinked list changes.
2200 */
2201 if (magic16 != XFS_DINODE_MAGIC) {
2202 xfs_warn(mp, "Bad INODE block magic!");
2203 ASSERT(0);
2204 break;
2205 }
2206 bp->b_ops = &xfs_inode_buf_ops;
2207 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002208 case XFS_BLFT_SYMLINK_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002209 if (magic32 != XFS_SYMLINK_MAGIC) {
2210 xfs_warn(mp, "Bad symlink block magic!");
2211 ASSERT(0);
2212 break;
2213 }
2214 bp->b_ops = &xfs_symlink_buf_ops;
2215 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002216 case XFS_BLFT_DIR_BLOCK_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002217 if (magic32 != XFS_DIR2_BLOCK_MAGIC &&
2218 magic32 != XFS_DIR3_BLOCK_MAGIC) {
2219 xfs_warn(mp, "Bad dir block magic!");
2220 ASSERT(0);
2221 break;
2222 }
2223 bp->b_ops = &xfs_dir3_block_buf_ops;
2224 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002225 case XFS_BLFT_DIR_DATA_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002226 if (magic32 != XFS_DIR2_DATA_MAGIC &&
2227 magic32 != XFS_DIR3_DATA_MAGIC) {
2228 xfs_warn(mp, "Bad dir data magic!");
2229 ASSERT(0);
2230 break;
2231 }
2232 bp->b_ops = &xfs_dir3_data_buf_ops;
2233 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002234 case XFS_BLFT_DIR_FREE_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002235 if (magic32 != XFS_DIR2_FREE_MAGIC &&
2236 magic32 != XFS_DIR3_FREE_MAGIC) {
2237 xfs_warn(mp, "Bad dir3 free magic!");
2238 ASSERT(0);
2239 break;
2240 }
2241 bp->b_ops = &xfs_dir3_free_buf_ops;
2242 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002243 case XFS_BLFT_DIR_LEAF1_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002244 if (magicda != XFS_DIR2_LEAF1_MAGIC &&
2245 magicda != XFS_DIR3_LEAF1_MAGIC) {
2246 xfs_warn(mp, "Bad dir leaf1 magic!");
2247 ASSERT(0);
2248 break;
2249 }
2250 bp->b_ops = &xfs_dir3_leaf1_buf_ops;
2251 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002252 case XFS_BLFT_DIR_LEAFN_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002253 if (magicda != XFS_DIR2_LEAFN_MAGIC &&
2254 magicda != XFS_DIR3_LEAFN_MAGIC) {
2255 xfs_warn(mp, "Bad dir leafn magic!");
2256 ASSERT(0);
2257 break;
2258 }
2259 bp->b_ops = &xfs_dir3_leafn_buf_ops;
2260 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002261 case XFS_BLFT_DA_NODE_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002262 if (magicda != XFS_DA_NODE_MAGIC &&
2263 magicda != XFS_DA3_NODE_MAGIC) {
2264 xfs_warn(mp, "Bad da node magic!");
2265 ASSERT(0);
2266 break;
2267 }
2268 bp->b_ops = &xfs_da3_node_buf_ops;
2269 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002270 case XFS_BLFT_ATTR_LEAF_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002271 if (magicda != XFS_ATTR_LEAF_MAGIC &&
2272 magicda != XFS_ATTR3_LEAF_MAGIC) {
2273 xfs_warn(mp, "Bad attr leaf magic!");
2274 ASSERT(0);
2275 break;
2276 }
2277 bp->b_ops = &xfs_attr3_leaf_buf_ops;
2278 break;
Dave Chinner61fe1352013-04-03 16:11:30 +11002279 case XFS_BLFT_ATTR_RMT_BUF:
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002280 if (!xfs_sb_version_hascrc(&mp->m_sb))
2281 break;
Dave Chinnercab09a82013-04-30 21:39:36 +10002282 if (magic32 != XFS_ATTR3_RMT_MAGIC) {
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002283 xfs_warn(mp, "Bad attr remote magic!");
2284 ASSERT(0);
2285 break;
2286 }
2287 bp->b_ops = &xfs_attr3_rmt_buf_ops;
2288 break;
Dave Chinner04a1e6c2013-04-03 16:11:31 +11002289 case XFS_BLFT_SB_BUF:
2290 if (magic32 != XFS_SB_MAGIC) {
2291 xfs_warn(mp, "Bad SB block magic!");
2292 ASSERT(0);
2293 break;
2294 }
2295 bp->b_ops = &xfs_sb_buf_ops;
2296 break;
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002297 default:
Dave Chinner61fe1352013-04-03 16:11:30 +11002298 xfs_warn(mp, "Unknown buffer type %d!",
2299 xfs_blft_from_flags(buf_f));
Dave Chinnerd75afeb2013-04-03 16:11:29 +11002300 break;
2301 }
2302}
2303
2304/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305 * Perform a 'normal' buffer recovery. Each logged region of the
2306 * buffer should be copied over the corresponding region in the
2307 * given buffer. The bitmap in the buf log format structure indicates
2308 * where to place the logged data.
2309 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310STATIC void
2311xlog_recover_do_reg_buffer(
Dave Chinner9abbc532010-04-13 15:06:46 +10002312 struct xfs_mount *mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 xlog_recover_item_t *item,
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002314 struct xfs_buf *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 xfs_buf_log_format_t *buf_f)
2316{
2317 int i;
2318 int bit;
2319 int nbits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320 int error;
2321
Dave Chinner9abbc532010-04-13 15:06:46 +10002322 trace_xfs_log_recover_buf_reg_buf(mp->m_log, buf_f);
2323
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 bit = 0;
2325 i = 1; /* 0 is the buf format structure */
2326 while (1) {
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002327 bit = xfs_next_bit(buf_f->blf_data_map,
2328 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 if (bit == -1)
2330 break;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002331 nbits = xfs_contig_bits(buf_f->blf_data_map,
2332 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 ASSERT(nbits > 0);
Christoph Hellwig4b809162007-08-16 15:37:36 +10002334 ASSERT(item->ri_buf[i].i_addr != NULL);
Dave Chinnerc1155412010-05-07 11:05:19 +10002335 ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0);
Dave Chinneraa0e8832012-04-23 15:58:52 +10002336 ASSERT(BBTOB(bp->b_io_length) >=
2337 ((uint)bit << XFS_BLF_SHIFT) + (nbits << XFS_BLF_SHIFT));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338
2339 /*
Dave Chinner709da6a2013-05-27 16:38:23 +10002340 * The dirty regions logged in the buffer, even though
2341 * contiguous, may span multiple chunks. This is because the
2342 * dirty region may span a physical page boundary in a buffer
2343 * and hence be split into two separate vectors for writing into
2344 * the log. Hence we need to trim nbits back to the length of
2345 * the current region being copied out of the log.
2346 */
2347 if (item->ri_buf[i].i_len < (nbits << XFS_BLF_SHIFT))
2348 nbits = item->ri_buf[i].i_len >> XFS_BLF_SHIFT;
2349
2350 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 * Do a sanity check if this is a dquot buffer. Just checking
2352 * the first dquot in the buffer should do. XXXThis is
2353 * probably a good thing to do for other buf types also.
2354 */
2355 error = 0;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002356 if (buf_f->blf_flags &
Dave Chinnerc1155412010-05-07 11:05:19 +10002357 (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002358 if (item->ri_buf[i].i_addr == NULL) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002359 xfs_alert(mp,
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002360 "XFS: NULL dquot in %s.", __func__);
2361 goto next;
2362 }
Jan Rekorajski8ec6dba2009-11-16 11:57:02 +00002363 if (item->ri_buf[i].i_len < sizeof(xfs_disk_dquot_t)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002364 xfs_alert(mp,
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002365 "XFS: dquot too small (%d) in %s.",
2366 item->ri_buf[i].i_len, __func__);
2367 goto next;
2368 }
Dave Chinner9aede1d2013-10-15 09:17:52 +11002369 error = xfs_dqcheck(mp, item->ri_buf[i].i_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 -1, 0, XFS_QMOPT_DOWARN,
2371 "dquot_buf_recover");
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002372 if (error)
2373 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 }
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002375
2376 memcpy(xfs_buf_offset(bp,
Dave Chinnerc1155412010-05-07 11:05:19 +10002377 (uint)bit << XFS_BLF_SHIFT), /* dest */
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002378 item->ri_buf[i].i_addr, /* source */
Dave Chinnerc1155412010-05-07 11:05:19 +10002379 nbits<<XFS_BLF_SHIFT); /* length */
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002380 next:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 i++;
2382 bit += nbits;
2383 }
2384
2385 /* Shouldn't be any more regions */
2386 ASSERT(i == item->ri_total);
Christoph Hellwigee1a47a2013-04-21 14:53:46 -05002387
Dave Chinner9222a9c2013-06-12 12:19:06 +10002388 /*
2389 * We can only do post recovery validation on items on CRC enabled
2390 * fielsystems as we need to know when the buffer was written to be able
2391 * to determine if we should have replayed the item. If we replay old
2392 * metadata over a newer buffer, then it will enter a temporarily
2393 * inconsistent state resulting in verification failures. Hence for now
2394 * just avoid the verification stage for non-crc filesystems
2395 */
2396 if (xfs_sb_version_hascrc(&mp->m_sb))
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002397 xlog_recover_validate_buf_type(mp, bp, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398}
2399
2400/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 * Perform a dquot buffer recovery.
Zhi Yong Wu8ba701e2013-08-12 03:15:01 +00002402 * Simple algorithm: if we have found a QUOTAOFF log item of the same type
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 * (ie. USR or GRP), then just toss this buffer away; don't recover it.
2404 * Else, treat it as a regular buffer and do recovery.
2405 */
2406STATIC void
2407xlog_recover_do_dquot_buffer(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002408 struct xfs_mount *mp,
2409 struct xlog *log,
2410 struct xlog_recover_item *item,
2411 struct xfs_buf *bp,
2412 struct xfs_buf_log_format *buf_f)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413{
2414 uint type;
2415
Dave Chinner9abbc532010-04-13 15:06:46 +10002416 trace_xfs_log_recover_buf_dquot_buf(log, buf_f);
2417
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 /*
2419 * Filesystems are required to send in quota flags at mount time.
2420 */
2421 if (mp->m_qflags == 0) {
2422 return;
2423 }
2424
2425 type = 0;
Dave Chinnerc1155412010-05-07 11:05:19 +10002426 if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427 type |= XFS_DQ_USER;
Dave Chinnerc1155412010-05-07 11:05:19 +10002428 if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002429 type |= XFS_DQ_PROJ;
Dave Chinnerc1155412010-05-07 11:05:19 +10002430 if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 type |= XFS_DQ_GROUP;
2432 /*
2433 * This type of quotas was turned off, so ignore this buffer
2434 */
2435 if (log->l_quotaoffs_flag & type)
2436 return;
2437
Dave Chinner9abbc532010-04-13 15:06:46 +10002438 xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439}
2440
2441/*
2442 * This routine replays a modification made to a buffer at runtime.
2443 * There are actually two types of buffer, regular and inode, which
2444 * are handled differently. Inode buffers are handled differently
2445 * in that we only recover a specific set of data from them, namely
2446 * the inode di_next_unlinked fields. This is because all other inode
2447 * data is actually logged via inode records and any data we replay
2448 * here which overlaps that may be stale.
2449 *
2450 * When meta-data buffers are freed at run time we log a buffer item
Dave Chinnerc1155412010-05-07 11:05:19 +10002451 * with the XFS_BLF_CANCEL bit set to indicate that previous copies
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 * of the buffer in the log should not be replayed at recovery time.
2453 * This is so that if the blocks covered by the buffer are reused for
2454 * file data before we crash we don't end up replaying old, freed
2455 * meta-data into a user's file.
2456 *
2457 * To handle the cancellation of buffer log items, we make two passes
2458 * over the log during recovery. During the first we build a table of
2459 * those buffers which have been cancelled, and during the second we
2460 * only replay those buffers which do not have corresponding cancel
Zhi Yong Wu34be5ff2013-08-07 10:11:07 +00002461 * records in the table. See xlog_recover_buffer_pass[1,2] above
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462 * for more details on the implementation of the table of cancel records.
2463 */
2464STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002465xlog_recover_buffer_pass2(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002466 struct xlog *log,
2467 struct list_head *buffer_list,
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002468 struct xlog_recover_item *item,
2469 xfs_lsn_t current_lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470{
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002471 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002472 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473 xfs_buf_t *bp;
2474 int error;
Christoph Hellwig6ad112b2009-11-24 18:02:23 +00002475 uint buf_flags;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002476 xfs_lsn_t lsn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002478 /*
2479 * In this pass we only want to recover all the buffers which have
2480 * not been cancelled and are not cancellation buffers themselves.
2481 */
2482 if (xlog_check_buffer_cancelled(log, buf_f->blf_blkno,
2483 buf_f->blf_len, buf_f->blf_flags)) {
2484 trace_xfs_log_recover_buf_cancel(log, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486 }
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002487
Dave Chinner9abbc532010-04-13 15:06:46 +10002488 trace_xfs_log_recover_buf_recover(log, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489
Dave Chinnera8acad72012-04-23 15:58:54 +10002490 buf_flags = 0;
Dave Chinner611c9942012-04-23 15:59:07 +10002491 if (buf_f->blf_flags & XFS_BLF_INODE_BUF)
2492 buf_flags |= XBF_UNMAPPED;
Christoph Hellwig6ad112b2009-11-24 18:02:23 +00002493
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002494 bp = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +11002495 buf_flags, NULL);
Chandra Seetharamanac4d6882011-08-03 02:18:29 +00002496 if (!bp)
2497 return XFS_ERROR(ENOMEM);
Chandra Seetharamane5702802011-08-03 02:18:34 +00002498 error = bp->b_error;
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +00002499 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +00002500 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002501 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502 }
2503
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002504 /*
2505 * recover the buffer only if we get an LSN from it and it's less than
2506 * the lsn of the transaction we are replaying.
2507 */
2508 lsn = xlog_recover_get_buf_lsn(mp, bp);
2509 if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0)
2510 goto out_release;
2511
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002512 if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513 error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002514 } else if (buf_f->blf_flags &
Dave Chinnerc1155412010-05-07 11:05:19 +10002515 (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
2517 } else {
Dave Chinner9abbc532010-04-13 15:06:46 +10002518 xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002519 }
2520 if (error)
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002521 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522
2523 /*
2524 * Perform delayed write on the buffer. Asynchronous writes will be
2525 * slower when taking into account all the buffers to be flushed.
2526 *
2527 * Also make sure that only inode buffers with good sizes stay in
2528 * the buffer cache. The kernel moves inodes in buffers of 1 block
Jie Liu0f49efd2013-12-13 15:51:48 +11002529 * or mp->m_inode_cluster_size bytes, whichever is bigger. The inode
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530 * buffers in the log can be a different size if the log was generated
2531 * by an older kernel using unclustered inode buffers or a newer kernel
2532 * running with a different inode cluster size. Regardless, if the
Jie Liu0f49efd2013-12-13 15:51:48 +11002533 * the inode buffer size isn't MAX(blocksize, mp->m_inode_cluster_size)
2534 * for *our* value of mp->m_inode_cluster_size, then we need to keep
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535 * the buffer out of the buffer cache so that the buffer won't
2536 * overlap with future reads of those inodes.
2537 */
2538 if (XFS_DINODE_MAGIC ==
Christoph Hellwigb53e6752007-10-12 10:59:34 +10002539 be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
Dave Chinneraa0e8832012-04-23 15:58:52 +10002540 (BBTOB(bp->b_io_length) != MAX(log->l_mp->m_sb.sb_blocksize,
Jie Liu0f49efd2013-12-13 15:51:48 +11002541 (__uint32_t)log->l_mp->m_inode_cluster_size))) {
Christoph Hellwigc867cb62011-10-10 16:52:46 +00002542 xfs_buf_stale(bp);
Christoph Hellwigc2b006c2011-08-23 08:28:07 +00002543 error = xfs_bwrite(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 } else {
Dave Chinnerebad8612010-09-22 10:47:20 +10002545 ASSERT(bp->b_target->bt_mount == mp);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02002546 bp->b_iodone = xlog_recover_iodone;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002547 xfs_buf_delwri_queue(bp, buffer_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 }
2549
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002550out_release:
Christoph Hellwigc2b006c2011-08-23 08:28:07 +00002551 xfs_buf_relse(bp);
2552 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553}
2554
Dave Chinner638f44162013-08-30 10:23:45 +10002555/*
2556 * Inode fork owner changes
2557 *
2558 * If we have been told that we have to reparent the inode fork, it's because an
2559 * extent swap operation on a CRC enabled filesystem has been done and we are
2560 * replaying it. We need to walk the BMBT of the appropriate fork and change the
2561 * owners of it.
2562 *
2563 * The complexity here is that we don't have an inode context to work with, so
2564 * after we've replayed the inode we need to instantiate one. This is where the
2565 * fun begins.
2566 *
2567 * We are in the middle of log recovery, so we can't run transactions. That
2568 * means we cannot use cache coherent inode instantiation via xfs_iget(), as
2569 * that will result in the corresponding iput() running the inode through
2570 * xfs_inactive(). If we've just replayed an inode core that changes the link
2571 * count to zero (i.e. it's been unlinked), then xfs_inactive() will run
2572 * transactions (bad!).
2573 *
2574 * So, to avoid this, we instantiate an inode directly from the inode core we've
2575 * just recovered. We have the buffer still locked, and all we really need to
2576 * instantiate is the inode core and the forks being modified. We can do this
2577 * manually, then run the inode btree owner change, and then tear down the
2578 * xfs_inode without having to run any transactions at all.
2579 *
2580 * Also, because we don't have a transaction context available here but need to
2581 * gather all the buffers we modify for writeback so we pass the buffer_list
2582 * instead for the operation to use.
2583 */
2584
2585STATIC int
2586xfs_recover_inode_owner_change(
2587 struct xfs_mount *mp,
2588 struct xfs_dinode *dip,
2589 struct xfs_inode_log_format *in_f,
2590 struct list_head *buffer_list)
2591{
2592 struct xfs_inode *ip;
2593 int error;
2594
2595 ASSERT(in_f->ilf_fields & (XFS_ILOG_DOWNER|XFS_ILOG_AOWNER));
2596
2597 ip = xfs_inode_alloc(mp, in_f->ilf_ino);
2598 if (!ip)
2599 return ENOMEM;
2600
2601 /* instantiate the inode */
2602 xfs_dinode_from_disk(&ip->i_d, dip);
2603 ASSERT(ip->i_d.di_version >= 3);
2604
2605 error = xfs_iformat_fork(ip, dip);
2606 if (error)
2607 goto out_free_ip;
2608
2609
2610 if (in_f->ilf_fields & XFS_ILOG_DOWNER) {
2611 ASSERT(in_f->ilf_fields & XFS_ILOG_DBROOT);
2612 error = xfs_bmbt_change_owner(NULL, ip, XFS_DATA_FORK,
2613 ip->i_ino, buffer_list);
2614 if (error)
2615 goto out_free_ip;
2616 }
2617
2618 if (in_f->ilf_fields & XFS_ILOG_AOWNER) {
2619 ASSERT(in_f->ilf_fields & XFS_ILOG_ABROOT);
2620 error = xfs_bmbt_change_owner(NULL, ip, XFS_ATTR_FORK,
2621 ip->i_ino, buffer_list);
2622 if (error)
2623 goto out_free_ip;
2624 }
2625
2626out_free_ip:
2627 xfs_inode_free(ip);
2628 return error;
2629}
2630
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002632xlog_recover_inode_pass2(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002633 struct xlog *log,
2634 struct list_head *buffer_list,
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002635 struct xlog_recover_item *item,
2636 xfs_lsn_t current_lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637{
2638 xfs_inode_log_format_t *in_f;
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002639 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 xfs_buf_t *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641 xfs_dinode_t *dip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642 int len;
2643 xfs_caddr_t src;
2644 xfs_caddr_t dest;
2645 int error;
2646 int attr_index;
2647 uint fields;
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002648 xfs_icdinode_t *dicp;
Christoph Hellwig93848a92013-04-03 16:11:17 +11002649 uint isize;
Tim Shimmin6d192a92006-06-09 14:55:38 +10002650 int need_free = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651
Tim Shimmin6d192a92006-06-09 14:55:38 +10002652 if (item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t)) {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002653 in_f = item->ri_buf[0].i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +10002654 } else {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002655 in_f = kmem_alloc(sizeof(xfs_inode_log_format_t), KM_SLEEP);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002656 need_free = 1;
2657 error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
2658 if (error)
2659 goto error;
2660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661
2662 /*
2663 * Inode buffers can be freed, look out for it,
2664 * and do not replay the inode.
2665 */
Christoph Hellwiga1941892008-11-28 14:23:40 +11002666 if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno,
2667 in_f->ilf_len, 0)) {
Tim Shimmin6d192a92006-06-09 14:55:38 +10002668 error = 0;
Dave Chinner9abbc532010-04-13 15:06:46 +10002669 trace_xfs_log_recover_inode_cancel(log, in_f);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002670 goto error;
2671 }
Dave Chinner9abbc532010-04-13 15:06:46 +10002672 trace_xfs_log_recover_inode_recover(log, in_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673
Dave Chinnerc3f8fc72012-11-12 22:54:01 +11002674 bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len, 0,
Christoph Hellwig93848a92013-04-03 16:11:17 +11002675 &xfs_inode_buf_ops);
Chandra Seetharamanac4d6882011-08-03 02:18:29 +00002676 if (!bp) {
2677 error = ENOMEM;
2678 goto error;
2679 }
Chandra Seetharamane5702802011-08-03 02:18:34 +00002680 error = bp->b_error;
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +00002681 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +00002682 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#2)");
Dave Chinner638f44162013-08-30 10:23:45 +10002683 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685 ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
Christoph Hellwiga1941892008-11-28 14:23:40 +11002686 dip = (xfs_dinode_t *)xfs_buf_offset(bp, in_f->ilf_boffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687
2688 /*
2689 * Make sure the place we're flushing out to really looks
2690 * like an inode!
2691 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002692 if (unlikely(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002693 xfs_alert(mp,
2694 "%s: Bad inode magic number, dip = 0x%p, dino bp = 0x%p, ino = %Ld",
2695 __func__, dip, bp, in_f->ilf_ino);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002696 XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697 XFS_ERRLEVEL_LOW, mp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002698 error = EFSCORRUPTED;
Dave Chinner638f44162013-08-30 10:23:45 +10002699 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 }
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002701 dicp = item->ri_buf[1].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002702 if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002703 xfs_alert(mp,
2704 "%s: Bad inode log record, rec ptr 0x%p, ino %Ld",
2705 __func__, item, in_f->ilf_ino);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002706 XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707 XFS_ERRLEVEL_LOW, mp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002708 error = EFSCORRUPTED;
Dave Chinner638f44162013-08-30 10:23:45 +10002709 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710 }
2711
Dave Chinnere60896d2013-07-24 15:47:30 +10002712 /*
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002713 * If the inode has an LSN in it, recover the inode only if it's less
Dave Chinner638f44162013-08-30 10:23:45 +10002714 * than the lsn of the transaction we are replaying. Note: we still
2715 * need to replay an owner change even though the inode is more recent
2716 * than the transaction as there is no guarantee that all the btree
2717 * blocks are more recent than this transaction, too.
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002718 */
2719 if (dip->di_version >= 3) {
2720 xfs_lsn_t lsn = be64_to_cpu(dip->di_lsn);
2721
2722 if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) {
2723 trace_xfs_log_recover_inode_skip(log, in_f);
2724 error = 0;
Dave Chinner638f44162013-08-30 10:23:45 +10002725 goto out_owner_change;
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002726 }
2727 }
2728
2729 /*
Dave Chinnere60896d2013-07-24 15:47:30 +10002730 * di_flushiter is only valid for v1/2 inodes. All changes for v3 inodes
2731 * are transactional and if ordering is necessary we can determine that
2732 * more accurately by the LSN field in the V3 inode core. Don't trust
2733 * the inode versions we might be changing them here - use the
2734 * superblock flag to determine whether we need to look at di_flushiter
2735 * to skip replay when the on disk inode is newer than the log one
2736 */
2737 if (!xfs_sb_version_hascrc(&mp->m_sb) &&
2738 dicp->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 /*
2740 * Deal with the wrap case, DI_MAX_FLUSH is less
2741 * than smaller numbers
2742 */
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002743 if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002744 dicp->di_flushiter < (DI_MAX_FLUSH >> 1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745 /* do nothing */
2746 } else {
Dave Chinner9abbc532010-04-13 15:06:46 +10002747 trace_xfs_log_recover_inode_skip(log, in_f);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002748 error = 0;
Dave Chinner638f44162013-08-30 10:23:45 +10002749 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750 }
2751 }
Dave Chinnere60896d2013-07-24 15:47:30 +10002752
Linus Torvalds1da177e2005-04-16 15:20:36 -07002753 /* Take the opportunity to reset the flush iteration count */
2754 dicp->di_flushiter = 0;
2755
Al Viroabbede12011-07-26 02:31:30 -04002756 if (unlikely(S_ISREG(dicp->di_mode))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2758 (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002759 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760 XFS_ERRLEVEL_LOW, mp, dicp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002761 xfs_alert(mp,
2762 "%s: Bad regular inode log record, rec ptr 0x%p, "
2763 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2764 __func__, item, dip, bp, in_f->ilf_ino);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002765 error = EFSCORRUPTED;
Dave Chinner638f44162013-08-30 10:23:45 +10002766 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 }
Al Viroabbede12011-07-26 02:31:30 -04002768 } else if (unlikely(S_ISDIR(dicp->di_mode))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2770 (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
2771 (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002772 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(4)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773 XFS_ERRLEVEL_LOW, mp, dicp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002774 xfs_alert(mp,
2775 "%s: Bad dir inode log record, rec ptr 0x%p, "
2776 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2777 __func__, item, dip, bp, in_f->ilf_ino);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002778 error = EFSCORRUPTED;
Dave Chinner638f44162013-08-30 10:23:45 +10002779 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 }
2781 }
2782 if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002783 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784 XFS_ERRLEVEL_LOW, mp, dicp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002785 xfs_alert(mp,
2786 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
2787 "dino bp 0x%p, ino %Ld, total extents = %d, nblocks = %Ld",
2788 __func__, item, dip, bp, in_f->ilf_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789 dicp->di_nextents + dicp->di_anextents,
2790 dicp->di_nblocks);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002791 error = EFSCORRUPTED;
Dave Chinner638f44162013-08-30 10:23:45 +10002792 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793 }
2794 if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002795 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002796 XFS_ERRLEVEL_LOW, mp, dicp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002797 xfs_alert(mp,
2798 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
2799 "dino bp 0x%p, ino %Ld, forkoff 0x%x", __func__,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002800 item, dip, bp, in_f->ilf_ino, dicp->di_forkoff);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002801 error = EFSCORRUPTED;
Dave Chinner638f44162013-08-30 10:23:45 +10002802 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803 }
Christoph Hellwig93848a92013-04-03 16:11:17 +11002804 isize = xfs_icdinode_size(dicp->di_version);
2805 if (unlikely(item->ri_buf[1].i_len > isize)) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002806 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807 XFS_ERRLEVEL_LOW, mp, dicp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002808 xfs_alert(mp,
2809 "%s: Bad inode log record length %d, rec ptr 0x%p",
2810 __func__, item->ri_buf[1].i_len, item);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002811 error = EFSCORRUPTED;
Dave Chinner638f44162013-08-30 10:23:45 +10002812 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813 }
2814
2815 /* The core is in in-core format */
Christoph Hellwig93848a92013-04-03 16:11:17 +11002816 xfs_dinode_to_disk(dip, dicp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817
2818 /* the rest is in on-disk format */
Christoph Hellwig93848a92013-04-03 16:11:17 +11002819 if (item->ri_buf[1].i_len > isize) {
2820 memcpy((char *)dip + isize,
2821 item->ri_buf[1].i_addr + isize,
2822 item->ri_buf[1].i_len - isize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 }
2824
2825 fields = in_f->ilf_fields;
2826 switch (fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) {
2827 case XFS_ILOG_DEV:
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002828 xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 break;
2830 case XFS_ILOG_UUID:
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002831 memcpy(XFS_DFORK_DPTR(dip),
2832 &in_f->ilf_u.ilfu_uuid,
2833 sizeof(uuid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834 break;
2835 }
2836
2837 if (in_f->ilf_size == 2)
Dave Chinner638f44162013-08-30 10:23:45 +10002838 goto out_owner_change;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839 len = item->ri_buf[2].i_len;
2840 src = item->ri_buf[2].i_addr;
2841 ASSERT(in_f->ilf_size <= 4);
2842 ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK));
2843 ASSERT(!(fields & XFS_ILOG_DFORK) ||
2844 (len == in_f->ilf_dsize));
2845
2846 switch (fields & XFS_ILOG_DFORK) {
2847 case XFS_ILOG_DDATA:
2848 case XFS_ILOG_DEXT:
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002849 memcpy(XFS_DFORK_DPTR(dip), src, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 break;
2851
2852 case XFS_ILOG_DBROOT:
Christoph Hellwig7cc95a82008-10-30 17:14:34 +11002853 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, len,
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002854 (xfs_bmdr_block_t *)XFS_DFORK_DPTR(dip),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 XFS_DFORK_DSIZE(dip, mp));
2856 break;
2857
2858 default:
2859 /*
2860 * There are no data fork flags set.
2861 */
2862 ASSERT((fields & XFS_ILOG_DFORK) == 0);
2863 break;
2864 }
2865
2866 /*
2867 * If we logged any attribute data, recover it. There may or
2868 * may not have been any other non-core data logged in this
2869 * transaction.
2870 */
2871 if (in_f->ilf_fields & XFS_ILOG_AFORK) {
2872 if (in_f->ilf_fields & XFS_ILOG_DFORK) {
2873 attr_index = 3;
2874 } else {
2875 attr_index = 2;
2876 }
2877 len = item->ri_buf[attr_index].i_len;
2878 src = item->ri_buf[attr_index].i_addr;
2879 ASSERT(len == in_f->ilf_asize);
2880
2881 switch (in_f->ilf_fields & XFS_ILOG_AFORK) {
2882 case XFS_ILOG_ADATA:
2883 case XFS_ILOG_AEXT:
2884 dest = XFS_DFORK_APTR(dip);
2885 ASSERT(len <= XFS_DFORK_ASIZE(dip, mp));
2886 memcpy(dest, src, len);
2887 break;
2888
2889 case XFS_ILOG_ABROOT:
2890 dest = XFS_DFORK_APTR(dip);
Christoph Hellwig7cc95a82008-10-30 17:14:34 +11002891 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src,
2892 len, (xfs_bmdr_block_t*)dest,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002893 XFS_DFORK_ASIZE(dip, mp));
2894 break;
2895
2896 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002897 xfs_warn(log->l_mp, "%s: Invalid flag", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898 ASSERT(0);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002899 error = EIO;
Dave Chinner638f44162013-08-30 10:23:45 +10002900 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901 }
2902 }
2903
Dave Chinner638f44162013-08-30 10:23:45 +10002904out_owner_change:
2905 if (in_f->ilf_fields & (XFS_ILOG_DOWNER|XFS_ILOG_AOWNER))
2906 error = xfs_recover_inode_owner_change(mp, dip, in_f,
2907 buffer_list);
Christoph Hellwig93848a92013-04-03 16:11:17 +11002908 /* re-generate the checksum. */
2909 xfs_dinode_calc_crc(log->l_mp, dip);
2910
Dave Chinnerebad8612010-09-22 10:47:20 +10002911 ASSERT(bp->b_target->bt_mount == mp);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02002912 bp->b_iodone = xlog_recover_iodone;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002913 xfs_buf_delwri_queue(bp, buffer_list);
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002914
2915out_release:
Christoph Hellwig61551f12011-08-23 08:28:06 +00002916 xfs_buf_relse(bp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002917error:
2918 if (need_free)
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002919 kmem_free(in_f);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002920 return XFS_ERROR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921}
2922
2923/*
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002924 * Recover QUOTAOFF records. We simply make a note of it in the xlog
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925 * structure, so that we know not to do any dquot item or dquot buffer recovery,
2926 * of that type.
2927 */
2928STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002929xlog_recover_quotaoff_pass1(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002930 struct xlog *log,
2931 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002933 xfs_qoff_logformat_t *qoff_f = item->ri_buf[0].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934 ASSERT(qoff_f);
2935
2936 /*
2937 * The logitem format's flag tells us if this was user quotaoff,
Nathan Scott77a7cce2006-01-11 15:35:57 +11002938 * group/project quotaoff or both.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939 */
2940 if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
2941 log->l_quotaoffs_flag |= XFS_DQ_USER;
Nathan Scott77a7cce2006-01-11 15:35:57 +11002942 if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
2943 log->l_quotaoffs_flag |= XFS_DQ_PROJ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
2945 log->l_quotaoffs_flag |= XFS_DQ_GROUP;
2946
2947 return (0);
2948}
2949
2950/*
2951 * Recover a dquot record
2952 */
2953STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002954xlog_recover_dquot_pass2(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002955 struct xlog *log,
2956 struct list_head *buffer_list,
Dave Chinner50d5c8d2013-08-28 21:22:47 +10002957 struct xlog_recover_item *item,
2958 xfs_lsn_t current_lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002960 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961 xfs_buf_t *bp;
2962 struct xfs_disk_dquot *ddq, *recddq;
2963 int error;
2964 xfs_dq_logformat_t *dq_f;
2965 uint type;
2966
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967
2968 /*
2969 * Filesystems are required to send in quota flags at mount time.
2970 */
2971 if (mp->m_qflags == 0)
2972 return (0);
2973
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002974 recddq = item->ri_buf[1].i_addr;
2975 if (recddq == NULL) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002976 xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002977 return XFS_ERROR(EIO);
2978 }
Jan Rekorajski8ec6dba2009-11-16 11:57:02 +00002979 if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002980 xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002981 item->ri_buf[1].i_len, __func__);
2982 return XFS_ERROR(EIO);
2983 }
2984
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985 /*
2986 * This type of quotas was turned off, so ignore this record.
2987 */
Christoph Hellwigb53e6752007-10-12 10:59:34 +10002988 type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989 ASSERT(type);
2990 if (log->l_quotaoffs_flag & type)
2991 return (0);
2992
2993 /*
2994 * At this point we know that quota was _not_ turned off.
2995 * Since the mount flags are not indicating to us otherwise, this
2996 * must mean that quota is on, and the dquot needs to be replayed.
2997 * Remember that we may not have fully recovered the superblock yet,
2998 * so we can't do the usual trick of looking at the SB quota bits.
2999 *
3000 * The other possibility, of course, is that the quota subsystem was
3001 * removed since the last mount - ENOSYS.
3002 */
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10003003 dq_f = item->ri_buf[0].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004 ASSERT(dq_f);
Dave Chinner9aede1d2013-10-15 09:17:52 +11003005 error = xfs_dqcheck(mp, recddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003006 "xlog_recover_dquot_pass2 (log copy)");
3007 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008 return XFS_ERROR(EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003009 ASSERT(dq_f->qlf_len == 1);
3010
Dave Chinner7ca790a2012-04-23 15:58:55 +10003011 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dq_f->qlf_blkno,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +11003012 XFS_FSB_TO_BB(mp, dq_f->qlf_len), 0, &bp,
3013 NULL);
Dave Chinner7ca790a2012-04-23 15:58:55 +10003014 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 return error;
Dave Chinner7ca790a2012-04-23 15:58:55 +10003016
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017 ASSERT(bp);
3018 ddq = (xfs_disk_dquot_t *)xfs_buf_offset(bp, dq_f->qlf_boffset);
3019
3020 /*
3021 * At least the magic num portion should be on disk because this
3022 * was among a chunk of dquots created earlier, and we did some
3023 * minimal initialization then.
3024 */
Dave Chinner9aede1d2013-10-15 09:17:52 +11003025 error = xfs_dqcheck(mp, ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003026 "xlog_recover_dquot_pass2");
3027 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028 xfs_buf_relse(bp);
3029 return XFS_ERROR(EIO);
3030 }
3031
Dave Chinner50d5c8d2013-08-28 21:22:47 +10003032 /*
3033 * If the dquot has an LSN in it, recover the dquot only if it's less
3034 * than the lsn of the transaction we are replaying.
3035 */
3036 if (xfs_sb_version_hascrc(&mp->m_sb)) {
3037 struct xfs_dqblk *dqb = (struct xfs_dqblk *)ddq;
3038 xfs_lsn_t lsn = be64_to_cpu(dqb->dd_lsn);
3039
3040 if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) {
3041 goto out_release;
3042 }
3043 }
3044
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 memcpy(ddq, recddq, item->ri_buf[1].i_len);
Dave Chinner6fcdc592013-06-03 15:28:46 +10003046 if (xfs_sb_version_hascrc(&mp->m_sb)) {
3047 xfs_update_cksum((char *)ddq, sizeof(struct xfs_dqblk),
3048 XFS_DQUOT_CRC_OFF);
3049 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003050
3051 ASSERT(dq_f->qlf_size == 2);
Dave Chinnerebad8612010-09-22 10:47:20 +10003052 ASSERT(bp->b_target->bt_mount == mp);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02003053 bp->b_iodone = xlog_recover_iodone;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10003054 xfs_buf_delwri_queue(bp, buffer_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055
Dave Chinner50d5c8d2013-08-28 21:22:47 +10003056out_release:
3057 xfs_buf_relse(bp);
3058 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059}
3060
3061/*
3062 * This routine is called to create an in-core extent free intent
3063 * item from the efi format structure which was logged on disk.
3064 * It allocates an in-core efi, copies the extents from the format
3065 * structure into it, and adds the efi to the AIL with the given
3066 * LSN.
3067 */
Tim Shimmin6d192a92006-06-09 14:55:38 +10003068STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003069xlog_recover_efi_pass2(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003070 struct xlog *log,
3071 struct xlog_recover_item *item,
3072 xfs_lsn_t lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003073{
Tim Shimmin6d192a92006-06-09 14:55:38 +10003074 int error;
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003075 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003076 xfs_efi_log_item_t *efip;
3077 xfs_efi_log_format_t *efi_formatp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10003079 efi_formatp = item->ri_buf[0].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003080
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081 efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
Tim Shimmin6d192a92006-06-09 14:55:38 +10003082 if ((error = xfs_efi_copy_format(&(item->ri_buf[0]),
3083 &(efip->efi_format)))) {
3084 xfs_efi_item_free(efip);
3085 return error;
3086 }
Dave Chinnerb199c8a2010-12-20 11:59:49 +11003087 atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003088
David Chinnera9c21c12008-10-30 17:39:35 +11003089 spin_lock(&log->l_ailp->xa_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090 /*
David Chinner783a2f62008-10-30 17:39:58 +11003091 * xfs_trans_ail_update() drops the AIL lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092 */
Dave Chinnere6059942010-12-20 12:34:26 +11003093 xfs_trans_ail_update(log->l_ailp, &efip->efi_item, lsn);
Tim Shimmin6d192a92006-06-09 14:55:38 +10003094 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095}
3096
3097
3098/*
3099 * This routine is called when an efd format structure is found in
3100 * a committed transaction in the log. It's purpose is to cancel
3101 * the corresponding efi if it was still in the log. To do this
3102 * it searches the AIL for the efi with an id equal to that in the
3103 * efd format structure. If we find it, we remove the efi from the
3104 * AIL and free it.
3105 */
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003106STATIC int
3107xlog_recover_efd_pass2(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003108 struct xlog *log,
3109 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003110{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003111 xfs_efd_log_format_t *efd_formatp;
3112 xfs_efi_log_item_t *efip = NULL;
3113 xfs_log_item_t *lip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 __uint64_t efi_id;
David Chinner27d8d5f2008-10-30 17:38:39 +11003115 struct xfs_ail_cursor cur;
David Chinner783a2f62008-10-30 17:39:58 +11003116 struct xfs_ail *ailp = log->l_ailp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10003118 efd_formatp = item->ri_buf[0].i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +10003119 ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) +
3120 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) ||
3121 (item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) +
3122 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t)))));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 efi_id = efd_formatp->efd_efi_id;
3124
3125 /*
3126 * Search for the efi with the id in the efd format structure
3127 * in the AIL.
3128 */
David Chinnera9c21c12008-10-30 17:39:35 +11003129 spin_lock(&ailp->xa_lock);
3130 lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003131 while (lip != NULL) {
3132 if (lip->li_type == XFS_LI_EFI) {
3133 efip = (xfs_efi_log_item_t *)lip;
3134 if (efip->efi_format.efi_id == efi_id) {
3135 /*
David Chinner783a2f62008-10-30 17:39:58 +11003136 * xfs_trans_ail_delete() drops the
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 * AIL lock.
3138 */
Dave Chinner04913fd2012-04-23 15:58:41 +10003139 xfs_trans_ail_delete(ailp, lip,
3140 SHUTDOWN_CORRUPT_INCORE);
David Chinner8ae2c0f2007-11-23 16:28:17 +11003141 xfs_efi_item_free(efip);
David Chinnera9c21c12008-10-30 17:39:35 +11003142 spin_lock(&ailp->xa_lock);
David Chinner27d8d5f2008-10-30 17:38:39 +11003143 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003144 }
3145 }
David Chinnera9c21c12008-10-30 17:39:35 +11003146 lip = xfs_trans_ail_cursor_next(ailp, &cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147 }
David Chinnera9c21c12008-10-30 17:39:35 +11003148 xfs_trans_ail_cursor_done(ailp, &cur);
3149 spin_unlock(&ailp->xa_lock);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003150
3151 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152}
3153
3154/*
Dave Chinner28c8e412013-06-27 16:04:55 +10003155 * This routine is called when an inode create format structure is found in a
3156 * committed transaction in the log. It's purpose is to initialise the inodes
3157 * being allocated on disk. This requires us to get inode cluster buffers that
3158 * match the range to be intialised, stamped with inode templates and written
3159 * by delayed write so that subsequent modifications will hit the cached buffer
3160 * and only need writing out at the end of recovery.
3161 */
3162STATIC int
3163xlog_recover_do_icreate_pass2(
3164 struct xlog *log,
3165 struct list_head *buffer_list,
3166 xlog_recover_item_t *item)
3167{
3168 struct xfs_mount *mp = log->l_mp;
3169 struct xfs_icreate_log *icl;
3170 xfs_agnumber_t agno;
3171 xfs_agblock_t agbno;
3172 unsigned int count;
3173 unsigned int isize;
3174 xfs_agblock_t length;
3175
3176 icl = (struct xfs_icreate_log *)item->ri_buf[0].i_addr;
3177 if (icl->icl_type != XFS_LI_ICREATE) {
3178 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad type");
3179 return EINVAL;
3180 }
3181
3182 if (icl->icl_size != 1) {
3183 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad icl size");
3184 return EINVAL;
3185 }
3186
3187 agno = be32_to_cpu(icl->icl_ag);
3188 if (agno >= mp->m_sb.sb_agcount) {
3189 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agno");
3190 return EINVAL;
3191 }
3192 agbno = be32_to_cpu(icl->icl_agbno);
3193 if (!agbno || agbno == NULLAGBLOCK || agbno >= mp->m_sb.sb_agblocks) {
3194 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agbno");
3195 return EINVAL;
3196 }
3197 isize = be32_to_cpu(icl->icl_isize);
3198 if (isize != mp->m_sb.sb_inodesize) {
3199 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad isize");
3200 return EINVAL;
3201 }
3202 count = be32_to_cpu(icl->icl_count);
3203 if (!count) {
3204 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count");
3205 return EINVAL;
3206 }
3207 length = be32_to_cpu(icl->icl_length);
3208 if (!length || length >= mp->m_sb.sb_agblocks) {
3209 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad length");
3210 return EINVAL;
3211 }
3212
3213 /* existing allocation is fixed value */
Jie Liu71783432013-12-13 15:51:46 +11003214 ASSERT(count == mp->m_ialloc_inos);
Jie Liu126cd102013-12-13 15:51:48 +11003215 ASSERT(length == mp->m_ialloc_blks);
Jie Liu71783432013-12-13 15:51:46 +11003216 if (count != mp->m_ialloc_inos ||
Jie Liu126cd102013-12-13 15:51:48 +11003217 length != mp->m_ialloc_blks) {
Dave Chinner28c8e412013-06-27 16:04:55 +10003218 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count 2");
3219 return EINVAL;
3220 }
3221
3222 /*
3223 * Inode buffers can be freed. Do not replay the inode initialisation as
3224 * we could be overwriting something written after this inode buffer was
3225 * cancelled.
3226 *
3227 * XXX: we need to iterate all buffers and only init those that are not
3228 * cancelled. I think that a more fine grained factoring of
3229 * xfs_ialloc_inode_init may be appropriate here to enable this to be
3230 * done easily.
3231 */
3232 if (xlog_check_buffer_cancelled(log,
3233 XFS_AGB_TO_DADDR(mp, agno, agbno), length, 0))
3234 return 0;
3235
3236 xfs_ialloc_inode_init(mp, NULL, buffer_list, agno, agbno, length,
3237 be32_to_cpu(icl->icl_gen));
3238 return 0;
3239}
3240
3241/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242 * Free up any resources allocated by the transaction
3243 *
3244 * Remember that EFIs, EFDs, and IUNLINKs are handled later.
3245 */
3246STATIC void
3247xlog_recover_free_trans(
Christoph Hellwigd0450942010-12-01 22:06:23 +00003248 struct xlog_recover *trans)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003249{
Dave Chinnerf0a76952010-01-11 11:49:57 +00003250 xlog_recover_item_t *item, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003251 int i;
3252
Dave Chinnerf0a76952010-01-11 11:49:57 +00003253 list_for_each_entry_safe(item, n, &trans->r_itemq, ri_list) {
3254 /* Free the regions in the item. */
3255 list_del(&item->ri_list);
3256 for (i = 0; i < item->ri_cnt; i++)
3257 kmem_free(item->ri_buf[i].i_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003258 /* Free the item itself */
Dave Chinnerf0a76952010-01-11 11:49:57 +00003259 kmem_free(item->ri_buf);
3260 kmem_free(item);
3261 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262 /* Free the transaction recover structure */
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10003263 kmem_free(trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264}
3265
Zhi Yong Wu00574da2013-08-14 15:16:03 +08003266STATIC void
3267xlog_recover_buffer_ra_pass2(
3268 struct xlog *log,
3269 struct xlog_recover_item *item)
3270{
3271 struct xfs_buf_log_format *buf_f = item->ri_buf[0].i_addr;
3272 struct xfs_mount *mp = log->l_mp;
3273
Dave Chinner84a5b732013-08-27 08:10:53 +10003274 if (xlog_peek_buffer_cancelled(log, buf_f->blf_blkno,
Zhi Yong Wu00574da2013-08-14 15:16:03 +08003275 buf_f->blf_len, buf_f->blf_flags)) {
3276 return;
3277 }
3278
3279 xfs_buf_readahead(mp->m_ddev_targp, buf_f->blf_blkno,
3280 buf_f->blf_len, NULL);
3281}
3282
3283STATIC void
3284xlog_recover_inode_ra_pass2(
3285 struct xlog *log,
3286 struct xlog_recover_item *item)
3287{
3288 struct xfs_inode_log_format ilf_buf;
3289 struct xfs_inode_log_format *ilfp;
3290 struct xfs_mount *mp = log->l_mp;
3291 int error;
3292
3293 if (item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format)) {
3294 ilfp = item->ri_buf[0].i_addr;
3295 } else {
3296 ilfp = &ilf_buf;
3297 memset(ilfp, 0, sizeof(*ilfp));
3298 error = xfs_inode_item_format_convert(&item->ri_buf[0], ilfp);
3299 if (error)
3300 return;
3301 }
3302
Dave Chinner84a5b732013-08-27 08:10:53 +10003303 if (xlog_peek_buffer_cancelled(log, ilfp->ilf_blkno, ilfp->ilf_len, 0))
Zhi Yong Wu00574da2013-08-14 15:16:03 +08003304 return;
3305
3306 xfs_buf_readahead(mp->m_ddev_targp, ilfp->ilf_blkno,
Dave Chinnerd8914002013-08-27 11:39:37 +10003307 ilfp->ilf_len, &xfs_inode_buf_ra_ops);
Zhi Yong Wu00574da2013-08-14 15:16:03 +08003308}
3309
3310STATIC void
3311xlog_recover_dquot_ra_pass2(
3312 struct xlog *log,
3313 struct xlog_recover_item *item)
3314{
3315 struct xfs_mount *mp = log->l_mp;
3316 struct xfs_disk_dquot *recddq;
3317 struct xfs_dq_logformat *dq_f;
3318 uint type;
3319
3320
3321 if (mp->m_qflags == 0)
3322 return;
3323
3324 recddq = item->ri_buf[1].i_addr;
3325 if (recddq == NULL)
3326 return;
3327 if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot))
3328 return;
3329
3330 type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
3331 ASSERT(type);
3332 if (log->l_quotaoffs_flag & type)
3333 return;
3334
3335 dq_f = item->ri_buf[0].i_addr;
3336 ASSERT(dq_f);
3337 ASSERT(dq_f->qlf_len == 1);
3338
3339 xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno,
Dave Chinner0f0d3342013-08-27 13:25:43 +10003340 XFS_FSB_TO_BB(mp, dq_f->qlf_len), NULL);
Zhi Yong Wu00574da2013-08-14 15:16:03 +08003341}
3342
3343STATIC void
3344xlog_recover_ra_pass2(
3345 struct xlog *log,
3346 struct xlog_recover_item *item)
3347{
3348 switch (ITEM_TYPE(item)) {
3349 case XFS_LI_BUF:
3350 xlog_recover_buffer_ra_pass2(log, item);
3351 break;
3352 case XFS_LI_INODE:
3353 xlog_recover_inode_ra_pass2(log, item);
3354 break;
3355 case XFS_LI_DQUOT:
3356 xlog_recover_dquot_ra_pass2(log, item);
3357 break;
3358 case XFS_LI_EFI:
3359 case XFS_LI_EFD:
3360 case XFS_LI_QUOTAOFF:
3361 default:
3362 break;
3363 }
3364}
3365
Linus Torvalds1da177e2005-04-16 15:20:36 -07003366STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003367xlog_recover_commit_pass1(
Mark Tinguelyad223e62012-06-14 09:22:15 -05003368 struct xlog *log,
3369 struct xlog_recover *trans,
3370 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003371{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003372 trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS1);
Christoph Hellwigd0450942010-12-01 22:06:23 +00003373
3374 switch (ITEM_TYPE(item)) {
3375 case XFS_LI_BUF:
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003376 return xlog_recover_buffer_pass1(log, item);
Christoph Hellwigd0450942010-12-01 22:06:23 +00003377 case XFS_LI_QUOTAOFF:
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003378 return xlog_recover_quotaoff_pass1(log, item);
3379 case XFS_LI_INODE:
3380 case XFS_LI_EFI:
3381 case XFS_LI_EFD:
3382 case XFS_LI_DQUOT:
Dave Chinner28c8e412013-06-27 16:04:55 +10003383 case XFS_LI_ICREATE:
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003384 /* nothing to do in pass 1 */
3385 return 0;
Christoph Hellwigd0450942010-12-01 22:06:23 +00003386 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003387 xfs_warn(log->l_mp, "%s: invalid item type (%d)",
3388 __func__, ITEM_TYPE(item));
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003389 ASSERT(0);
3390 return XFS_ERROR(EIO);
3391 }
3392}
3393
3394STATIC int
3395xlog_recover_commit_pass2(
Mark Tinguelyad223e62012-06-14 09:22:15 -05003396 struct xlog *log,
3397 struct xlog_recover *trans,
3398 struct list_head *buffer_list,
3399 struct xlog_recover_item *item)
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003400{
3401 trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS2);
3402
3403 switch (ITEM_TYPE(item)) {
3404 case XFS_LI_BUF:
Dave Chinner50d5c8d2013-08-28 21:22:47 +10003405 return xlog_recover_buffer_pass2(log, buffer_list, item,
3406 trans->r_lsn);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003407 case XFS_LI_INODE:
Dave Chinner50d5c8d2013-08-28 21:22:47 +10003408 return xlog_recover_inode_pass2(log, buffer_list, item,
3409 trans->r_lsn);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003410 case XFS_LI_EFI:
3411 return xlog_recover_efi_pass2(log, item, trans->r_lsn);
3412 case XFS_LI_EFD:
3413 return xlog_recover_efd_pass2(log, item);
3414 case XFS_LI_DQUOT:
Dave Chinner50d5c8d2013-08-28 21:22:47 +10003415 return xlog_recover_dquot_pass2(log, buffer_list, item,
3416 trans->r_lsn);
Dave Chinner28c8e412013-06-27 16:04:55 +10003417 case XFS_LI_ICREATE:
3418 return xlog_recover_do_icreate_pass2(log, buffer_list, item);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003419 case XFS_LI_QUOTAOFF:
3420 /* nothing to do in pass2 */
3421 return 0;
3422 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003423 xfs_warn(log->l_mp, "%s: invalid item type (%d)",
3424 __func__, ITEM_TYPE(item));
Christoph Hellwigd0450942010-12-01 22:06:23 +00003425 ASSERT(0);
3426 return XFS_ERROR(EIO);
3427 }
3428}
3429
Zhi Yong Wu00574da2013-08-14 15:16:03 +08003430STATIC int
3431xlog_recover_items_pass2(
3432 struct xlog *log,
3433 struct xlog_recover *trans,
3434 struct list_head *buffer_list,
3435 struct list_head *item_list)
3436{
3437 struct xlog_recover_item *item;
3438 int error = 0;
3439
3440 list_for_each_entry(item, item_list, ri_list) {
3441 error = xlog_recover_commit_pass2(log, trans,
3442 buffer_list, item);
3443 if (error)
3444 return error;
3445 }
3446
3447 return error;
3448}
3449
Christoph Hellwigd0450942010-12-01 22:06:23 +00003450/*
3451 * Perform the transaction.
3452 *
3453 * If the transaction modifies a buffer or inode, do it now. Otherwise,
3454 * EFIs and EFDs get queued up by adding entries into the AIL for them.
3455 */
3456STATIC int
3457xlog_recover_commit_trans(
Mark Tinguelyad223e62012-06-14 09:22:15 -05003458 struct xlog *log,
Christoph Hellwigd0450942010-12-01 22:06:23 +00003459 struct xlog_recover *trans,
3460 int pass)
3461{
Zhi Yong Wu00574da2013-08-14 15:16:03 +08003462 int error = 0;
3463 int error2;
3464 int items_queued = 0;
3465 struct xlog_recover_item *item;
3466 struct xlog_recover_item *next;
3467 LIST_HEAD (buffer_list);
3468 LIST_HEAD (ra_list);
3469 LIST_HEAD (done_list);
3470
3471 #define XLOG_RECOVER_COMMIT_QUEUE_MAX 100
Linus Torvalds1da177e2005-04-16 15:20:36 -07003472
Dave Chinnerf0a76952010-01-11 11:49:57 +00003473 hlist_del(&trans->r_list);
Christoph Hellwigd0450942010-12-01 22:06:23 +00003474
3475 error = xlog_recover_reorder_trans(log, trans, pass);
3476 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477 return error;
Christoph Hellwigd0450942010-12-01 22:06:23 +00003478
Zhi Yong Wu00574da2013-08-14 15:16:03 +08003479 list_for_each_entry_safe(item, next, &trans->r_itemq, ri_list) {
Christoph Hellwig43ff2122012-04-23 15:58:39 +10003480 switch (pass) {
3481 case XLOG_RECOVER_PASS1:
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00003482 error = xlog_recover_commit_pass1(log, trans, item);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10003483 break;
3484 case XLOG_RECOVER_PASS2:
Zhi Yong Wu00574da2013-08-14 15:16:03 +08003485 xlog_recover_ra_pass2(log, item);
3486 list_move_tail(&item->ri_list, &ra_list);
3487 items_queued++;
3488 if (items_queued >= XLOG_RECOVER_COMMIT_QUEUE_MAX) {
3489 error = xlog_recover_items_pass2(log, trans,
3490 &buffer_list, &ra_list);
3491 list_splice_tail_init(&ra_list, &done_list);
3492 items_queued = 0;
3493 }
3494
Christoph Hellwig43ff2122012-04-23 15:58:39 +10003495 break;
3496 default:
3497 ASSERT(0);
3498 }
3499
Christoph Hellwigd0450942010-12-01 22:06:23 +00003500 if (error)
Christoph Hellwig43ff2122012-04-23 15:58:39 +10003501 goto out;
Christoph Hellwigd0450942010-12-01 22:06:23 +00003502 }
3503
Zhi Yong Wu00574da2013-08-14 15:16:03 +08003504out:
3505 if (!list_empty(&ra_list)) {
3506 if (!error)
3507 error = xlog_recover_items_pass2(log, trans,
3508 &buffer_list, &ra_list);
3509 list_splice_tail_init(&ra_list, &done_list);
3510 }
3511
3512 if (!list_empty(&done_list))
3513 list_splice_init(&done_list, &trans->r_itemq);
3514
Christoph Hellwigd0450942010-12-01 22:06:23 +00003515 xlog_recover_free_trans(trans);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10003516
Christoph Hellwig43ff2122012-04-23 15:58:39 +10003517 error2 = xfs_buf_delwri_submit(&buffer_list);
3518 return error ? error : error2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519}
3520
3521STATIC int
3522xlog_recover_unmount_trans(
Mark Tinguelyad223e62012-06-14 09:22:15 -05003523 struct xlog *log,
3524 struct xlog_recover *trans)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003525{
3526 /* Do nothing now */
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003527 xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003528 return 0;
3529}
3530
3531/*
3532 * There are two valid states of the r_state field. 0 indicates that the
3533 * transaction structure is in a normal state. We have either seen the
3534 * start of the transaction or the last operation we added was not a partial
3535 * operation. If the last operation we added to the transaction was a
3536 * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
3537 *
3538 * NOTE: skip LRs with 0 data length.
3539 */
3540STATIC int
3541xlog_recover_process_data(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003542 struct xlog *log,
Dave Chinnerf0a76952010-01-11 11:49:57 +00003543 struct hlist_head rhash[],
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003544 struct xlog_rec_header *rhead,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003545 xfs_caddr_t dp,
3546 int pass)
3547{
3548 xfs_caddr_t lp;
3549 int num_logops;
3550 xlog_op_header_t *ohead;
3551 xlog_recover_t *trans;
3552 xlog_tid_t tid;
3553 int error;
3554 unsigned long hash;
3555 uint flags;
3556
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003557 lp = dp + be32_to_cpu(rhead->h_len);
3558 num_logops = be32_to_cpu(rhead->h_num_logops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003559
3560 /* check the log format matches our own - else we can't recover */
3561 if (xlog_header_check_recover(log->l_mp, rhead))
3562 return (XFS_ERROR(EIO));
3563
3564 while ((dp < lp) && num_logops) {
3565 ASSERT(dp + sizeof(xlog_op_header_t) <= lp);
3566 ohead = (xlog_op_header_t *)dp;
3567 dp += sizeof(xlog_op_header_t);
3568 if (ohead->oh_clientid != XFS_TRANSACTION &&
3569 ohead->oh_clientid != XFS_LOG) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003570 xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
3571 __func__, ohead->oh_clientid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003572 ASSERT(0);
3573 return (XFS_ERROR(EIO));
3574 }
Christoph Hellwig67fcb7b2007-10-12 10:58:59 +10003575 tid = be32_to_cpu(ohead->oh_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003576 hash = XLOG_RHASH(tid);
Dave Chinnerf0a76952010-01-11 11:49:57 +00003577 trans = xlog_recover_find_tid(&rhash[hash], tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003578 if (trans == NULL) { /* not found; add new tid */
3579 if (ohead->oh_flags & XLOG_START_TRANS)
3580 xlog_recover_new_tid(&rhash[hash], tid,
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003581 be64_to_cpu(rhead->h_lsn));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582 } else {
Lachlan McIlroy9742bb92008-01-10 16:43:36 +11003583 if (dp + be32_to_cpu(ohead->oh_len) > lp) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003584 xfs_warn(log->l_mp, "%s: bad length 0x%x",
3585 __func__, be32_to_cpu(ohead->oh_len));
Lachlan McIlroy9742bb92008-01-10 16:43:36 +11003586 WARN_ON(1);
3587 return (XFS_ERROR(EIO));
3588 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003589 flags = ohead->oh_flags & ~XLOG_END_TRANS;
3590 if (flags & XLOG_WAS_CONT_TRANS)
3591 flags &= ~XLOG_CONTINUE_TRANS;
3592 switch (flags) {
3593 case XLOG_COMMIT_TRANS:
3594 error = xlog_recover_commit_trans(log,
Dave Chinnerf0a76952010-01-11 11:49:57 +00003595 trans, pass);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003596 break;
3597 case XLOG_UNMOUNT_TRANS:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003598 error = xlog_recover_unmount_trans(log, trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003599 break;
3600 case XLOG_WAS_CONT_TRANS:
Dave Chinner9abbc532010-04-13 15:06:46 +10003601 error = xlog_recover_add_to_cont_trans(log,
3602 trans, dp,
3603 be32_to_cpu(ohead->oh_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003604 break;
3605 case XLOG_START_TRANS:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003606 xfs_warn(log->l_mp, "%s: bad transaction",
3607 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003608 ASSERT(0);
3609 error = XFS_ERROR(EIO);
3610 break;
3611 case 0:
3612 case XLOG_CONTINUE_TRANS:
Dave Chinner9abbc532010-04-13 15:06:46 +10003613 error = xlog_recover_add_to_trans(log, trans,
Christoph Hellwig67fcb7b2007-10-12 10:58:59 +10003614 dp, be32_to_cpu(ohead->oh_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003615 break;
3616 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003617 xfs_warn(log->l_mp, "%s: bad flag 0x%x",
3618 __func__, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619 ASSERT(0);
3620 error = XFS_ERROR(EIO);
3621 break;
3622 }
Mark Tinguely2a841082013-10-02 07:51:12 -05003623 if (error) {
3624 xlog_recover_free_trans(trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003625 return error;
Mark Tinguely2a841082013-10-02 07:51:12 -05003626 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003627 }
Christoph Hellwig67fcb7b2007-10-12 10:58:59 +10003628 dp += be32_to_cpu(ohead->oh_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003629 num_logops--;
3630 }
3631 return 0;
3632}
3633
3634/*
3635 * Process an extent free intent item that was recovered from
3636 * the log. We need to free the extents that it describes.
3637 */
David Chinner3c1e2bb2008-04-10 12:21:11 +10003638STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003639xlog_recover_process_efi(
3640 xfs_mount_t *mp,
3641 xfs_efi_log_item_t *efip)
3642{
3643 xfs_efd_log_item_t *efdp;
3644 xfs_trans_t *tp;
3645 int i;
David Chinner3c1e2bb2008-04-10 12:21:11 +10003646 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003647 xfs_extent_t *extp;
3648 xfs_fsblock_t startblock_fsb;
3649
Dave Chinnerb199c8a2010-12-20 11:59:49 +11003650 ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003651
3652 /*
3653 * First check the validity of the extents described by the
3654 * EFI. If any are bad, then assume that all are bad and
3655 * just toss the EFI.
3656 */
3657 for (i = 0; i < efip->efi_format.efi_nextents; i++) {
3658 extp = &(efip->efi_format.efi_extents[i]);
3659 startblock_fsb = XFS_BB_TO_FSB(mp,
3660 XFS_FSB_TO_DADDR(mp, extp->ext_start));
3661 if ((startblock_fsb == 0) ||
3662 (extp->ext_len == 0) ||
3663 (startblock_fsb >= mp->m_sb.sb_dblocks) ||
3664 (extp->ext_len >= mp->m_sb.sb_agblocks)) {
3665 /*
3666 * This will pull the EFI from the AIL and
3667 * free the memory associated with it.
3668 */
Dave Chinner666d6442013-04-03 14:09:21 +11003669 set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003670 xfs_efi_release(efip, efip->efi_format.efi_nextents);
David Chinner3c1e2bb2008-04-10 12:21:11 +10003671 return XFS_ERROR(EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003672 }
3673 }
3674
3675 tp = xfs_trans_alloc(mp, 0);
Jie Liu3d3c8b52013-08-12 20:49:59 +10003676 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
David Chinnerfc6149d2008-04-10 12:21:53 +10003677 if (error)
3678 goto abort_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003679 efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
3680
3681 for (i = 0; i < efip->efi_format.efi_nextents; i++) {
3682 extp = &(efip->efi_format.efi_extents[i]);
David Chinnerfc6149d2008-04-10 12:21:53 +10003683 error = xfs_free_extent(tp, extp->ext_start, extp->ext_len);
3684 if (error)
3685 goto abort_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003686 xfs_trans_log_efd_extent(tp, efdp, extp->ext_start,
3687 extp->ext_len);
3688 }
3689
Dave Chinnerb199c8a2010-12-20 11:59:49 +11003690 set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
David Chinnere5720ee2008-04-10 12:21:18 +10003691 error = xfs_trans_commit(tp, 0);
David Chinner3c1e2bb2008-04-10 12:21:11 +10003692 return error;
David Chinnerfc6149d2008-04-10 12:21:53 +10003693
3694abort_error:
3695 xfs_trans_cancel(tp, XFS_TRANS_ABORT);
3696 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003697}
3698
3699/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003700 * When this is called, all of the EFIs which did not have
3701 * corresponding EFDs should be in the AIL. What we do now
3702 * is free the extents associated with each one.
3703 *
3704 * Since we process the EFIs in normal transactions, they
3705 * will be removed at some point after the commit. This prevents
3706 * us from just walking down the list processing each one.
3707 * We'll use a flag in the EFI to skip those that we've already
3708 * processed and use the AIL iteration mechanism's generation
3709 * count to try to speed this up at least a bit.
3710 *
3711 * When we start, we know that the EFIs are the only things in
3712 * the AIL. As we process them, however, other items are added
3713 * to the AIL. Since everything added to the AIL must come after
3714 * everything already in the AIL, we stop processing as soon as
3715 * we see something other than an EFI in the AIL.
3716 */
David Chinner3c1e2bb2008-04-10 12:21:11 +10003717STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003718xlog_recover_process_efis(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003719 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003720{
3721 xfs_log_item_t *lip;
3722 xfs_efi_log_item_t *efip;
David Chinner3c1e2bb2008-04-10 12:21:11 +10003723 int error = 0;
David Chinner27d8d5f2008-10-30 17:38:39 +11003724 struct xfs_ail_cursor cur;
David Chinnera9c21c12008-10-30 17:39:35 +11003725 struct xfs_ail *ailp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003726
David Chinnera9c21c12008-10-30 17:39:35 +11003727 ailp = log->l_ailp;
3728 spin_lock(&ailp->xa_lock);
3729 lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003730 while (lip != NULL) {
3731 /*
3732 * We're done when we see something other than an EFI.
David Chinner27d8d5f2008-10-30 17:38:39 +11003733 * There should be no EFIs left in the AIL now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003734 */
3735 if (lip->li_type != XFS_LI_EFI) {
David Chinner27d8d5f2008-10-30 17:38:39 +11003736#ifdef DEBUG
David Chinnera9c21c12008-10-30 17:39:35 +11003737 for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
David Chinner27d8d5f2008-10-30 17:38:39 +11003738 ASSERT(lip->li_type != XFS_LI_EFI);
3739#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003740 break;
3741 }
3742
3743 /*
3744 * Skip EFIs that we've already processed.
3745 */
3746 efip = (xfs_efi_log_item_t *)lip;
Dave Chinnerb199c8a2010-12-20 11:59:49 +11003747 if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)) {
David Chinnera9c21c12008-10-30 17:39:35 +11003748 lip = xfs_trans_ail_cursor_next(ailp, &cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003749 continue;
3750 }
3751
David Chinnera9c21c12008-10-30 17:39:35 +11003752 spin_unlock(&ailp->xa_lock);
3753 error = xlog_recover_process_efi(log->l_mp, efip);
3754 spin_lock(&ailp->xa_lock);
David Chinner27d8d5f2008-10-30 17:38:39 +11003755 if (error)
3756 goto out;
David Chinnera9c21c12008-10-30 17:39:35 +11003757 lip = xfs_trans_ail_cursor_next(ailp, &cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003758 }
David Chinner27d8d5f2008-10-30 17:38:39 +11003759out:
David Chinnera9c21c12008-10-30 17:39:35 +11003760 xfs_trans_ail_cursor_done(ailp, &cur);
3761 spin_unlock(&ailp->xa_lock);
David Chinner3c1e2bb2008-04-10 12:21:11 +10003762 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003763}
3764
3765/*
3766 * This routine performs a transaction to null out a bad inode pointer
3767 * in an agi unlinked inode hash bucket.
3768 */
3769STATIC void
3770xlog_recover_clear_agi_bucket(
3771 xfs_mount_t *mp,
3772 xfs_agnumber_t agno,
3773 int bucket)
3774{
3775 xfs_trans_t *tp;
3776 xfs_agi_t *agi;
3777 xfs_buf_t *agibp;
3778 int offset;
3779 int error;
3780
3781 tp = xfs_trans_alloc(mp, XFS_TRANS_CLEAR_AGI_BUCKET);
Jie Liu3d3c8b52013-08-12 20:49:59 +10003782 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_clearagi, 0, 0);
David Chinnere5720ee2008-04-10 12:21:18 +10003783 if (error)
3784 goto out_abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003785
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003786 error = xfs_read_agi(mp, tp, agno, &agibp);
3787 if (error)
David Chinnere5720ee2008-04-10 12:21:18 +10003788 goto out_abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003789
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003790 agi = XFS_BUF_TO_AGI(agibp);
Christoph Hellwig16259e72005-11-02 15:11:25 +11003791 agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003792 offset = offsetof(xfs_agi_t, agi_unlinked) +
3793 (sizeof(xfs_agino_t) * bucket);
3794 xfs_trans_log_buf(tp, agibp, offset,
3795 (offset + sizeof(xfs_agino_t) - 1));
3796
David Chinnere5720ee2008-04-10 12:21:18 +10003797 error = xfs_trans_commit(tp, 0);
3798 if (error)
3799 goto out_error;
3800 return;
3801
3802out_abort:
3803 xfs_trans_cancel(tp, XFS_TRANS_ABORT);
3804out_error:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003805 xfs_warn(mp, "%s: failed to clear agi %d. Continuing.", __func__, agno);
David Chinnere5720ee2008-04-10 12:21:18 +10003806 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003807}
3808
Christoph Hellwig23fac502008-11-28 14:23:40 +11003809STATIC xfs_agino_t
3810xlog_recover_process_one_iunlink(
3811 struct xfs_mount *mp,
3812 xfs_agnumber_t agno,
3813 xfs_agino_t agino,
3814 int bucket)
3815{
3816 struct xfs_buf *ibp;
3817 struct xfs_dinode *dip;
3818 struct xfs_inode *ip;
3819 xfs_ino_t ino;
3820 int error;
3821
3822 ino = XFS_AGINO_TO_INO(mp, agno, agino);
Dave Chinner7b6259e2010-06-24 11:35:17 +10003823 error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003824 if (error)
3825 goto fail;
3826
3827 /*
3828 * Get the on disk inode to find the next inode in the bucket.
3829 */
Christoph Hellwig475ee412012-07-03 12:21:22 -04003830 error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &ibp, 0, 0);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003831 if (error)
Christoph Hellwig0e446672008-11-28 14:23:42 +11003832 goto fail_iput;
Christoph Hellwig23fac502008-11-28 14:23:40 +11003833
Christoph Hellwig23fac502008-11-28 14:23:40 +11003834 ASSERT(ip->i_d.di_nlink == 0);
Christoph Hellwig0e446672008-11-28 14:23:42 +11003835 ASSERT(ip->i_d.di_mode != 0);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003836
3837 /* setup for the next pass */
3838 agino = be32_to_cpu(dip->di_next_unlinked);
3839 xfs_buf_relse(ibp);
3840
3841 /*
3842 * Prevent any DMAPI event from being sent when the reference on
3843 * the inode is dropped.
3844 */
3845 ip->i_d.di_dmevmask = 0;
3846
Christoph Hellwig0e446672008-11-28 14:23:42 +11003847 IRELE(ip);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003848 return agino;
3849
Christoph Hellwig0e446672008-11-28 14:23:42 +11003850 fail_iput:
3851 IRELE(ip);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003852 fail:
3853 /*
3854 * We can't read in the inode this bucket points to, or this inode
3855 * is messed up. Just ditch this bucket of inodes. We will lose
3856 * some inodes and space, but at least we won't hang.
3857 *
3858 * Call xlog_recover_clear_agi_bucket() to perform a transaction to
3859 * clear the inode pointer in the bucket.
3860 */
3861 xlog_recover_clear_agi_bucket(mp, agno, bucket);
3862 return NULLAGINO;
3863}
3864
Linus Torvalds1da177e2005-04-16 15:20:36 -07003865/*
3866 * xlog_iunlink_recover
3867 *
3868 * This is called during recovery to process any inodes which
3869 * we unlinked but not freed when the system crashed. These
3870 * inodes will be on the lists in the AGI blocks. What we do
3871 * here is scan all the AGIs and fully truncate and free any
3872 * inodes found on the lists. Each inode is removed from the
3873 * lists when it has been fully truncated and is freed. The
3874 * freeing of the inode and its removal from the list must be
3875 * atomic.
3876 */
Eric Sandeend96f8f82009-07-02 00:09:33 -05003877STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07003878xlog_recover_process_iunlinks(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003879 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003880{
3881 xfs_mount_t *mp;
3882 xfs_agnumber_t agno;
3883 xfs_agi_t *agi;
3884 xfs_buf_t *agibp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003885 xfs_agino_t agino;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003886 int bucket;
3887 int error;
3888 uint mp_dmevmask;
3889
3890 mp = log->l_mp;
3891
3892 /*
3893 * Prevent any DMAPI event from being sent while in this function.
3894 */
3895 mp_dmevmask = mp->m_dmevmask;
3896 mp->m_dmevmask = 0;
3897
3898 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
3899 /*
3900 * Find the agi for this ag.
3901 */
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003902 error = xfs_read_agi(mp, NULL, agno, &agibp);
3903 if (error) {
3904 /*
3905 * AGI is b0rked. Don't process it.
3906 *
3907 * We should probably mark the filesystem as corrupt
3908 * after we've recovered all the ag's we can....
3909 */
3910 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003911 }
Jan Karad97d32e2012-03-15 09:34:02 +00003912 /*
3913 * Unlock the buffer so that it can be acquired in the normal
3914 * course of the transaction to truncate and free each inode.
3915 * Because we are not racing with anyone else here for the AGI
3916 * buffer, we don't even need to hold it locked to read the
3917 * initial unlinked bucket entries out of the buffer. We keep
3918 * buffer reference though, so that it stays pinned in memory
3919 * while we need the buffer.
3920 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003921 agi = XFS_BUF_TO_AGI(agibp);
Jan Karad97d32e2012-03-15 09:34:02 +00003922 xfs_buf_unlock(agibp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003923
3924 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) {
Christoph Hellwig16259e72005-11-02 15:11:25 +11003925 agino = be32_to_cpu(agi->agi_unlinked[bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003926 while (agino != NULLAGINO) {
Christoph Hellwig23fac502008-11-28 14:23:40 +11003927 agino = xlog_recover_process_one_iunlink(mp,
3928 agno, agino, bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003929 }
3930 }
Jan Karad97d32e2012-03-15 09:34:02 +00003931 xfs_buf_rele(agibp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003932 }
3933
3934 mp->m_dmevmask = mp_dmevmask;
3935}
3936
Linus Torvalds1da177e2005-04-16 15:20:36 -07003937/*
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003938 * Upack the log buffer data and crc check it. If the check fails, issue a
3939 * warning if and only if the CRC in the header is non-zero. This makes the
3940 * check an advisory warning, and the zero CRC check will prevent failure
3941 * warnings from being emitted when upgrading the kernel from one that does not
3942 * add CRCs by default.
3943 *
3944 * When filesystems are CRC enabled, this CRC mismatch becomes a fatal log
3945 * corruption failure
Linus Torvalds1da177e2005-04-16 15:20:36 -07003946 */
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003947STATIC int
3948xlog_unpack_data_crc(
3949 struct xlog_rec_header *rhead,
3950 xfs_caddr_t dp,
3951 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003952{
Dave Chinnerf9668a02012-11-28 13:01:03 +11003953 __le32 crc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003954
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003955 crc = xlog_cksum(log, rhead, dp, be32_to_cpu(rhead->h_len));
3956 if (crc != rhead->h_crc) {
3957 if (rhead->h_crc || xfs_sb_version_hascrc(&log->l_mp->m_sb)) {
3958 xfs_alert(log->l_mp,
Eric Sandeen08e96e12013-10-11 20:59:05 -05003959 "log record CRC mismatch: found 0x%x, expected 0x%x.",
Dave Chinnerf9668a02012-11-28 13:01:03 +11003960 le32_to_cpu(rhead->h_crc),
3961 le32_to_cpu(crc));
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003962 xfs_hex_dump(dp, 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003963 }
3964
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003965 /*
3966 * If we've detected a log record corruption, then we can't
3967 * recover past this point. Abort recovery if we are enforcing
3968 * CRC protection by punting an error back up the stack.
3969 */
3970 if (xfs_sb_version_hascrc(&log->l_mp->m_sb))
3971 return EFSCORRUPTED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972 }
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003973
3974 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003975}
3976
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003977STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003978xlog_unpack_data(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003979 struct xlog_rec_header *rhead,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003980 xfs_caddr_t dp,
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003981 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003982{
3983 int i, j, k;
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003984 int error;
3985
3986 error = xlog_unpack_data_crc(rhead, dp, log);
3987 if (error)
3988 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003989
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003990 for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003991 i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003992 *(__be32 *)dp = *(__be32 *)&rhead->h_cycle_data[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003993 dp += BBSIZE;
3994 }
3995
Eric Sandeen62118702008-03-06 13:44:28 +11003996 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Christoph Hellwigb28708d2008-11-28 14:23:38 +11003997 xlog_in_core_2_t *xhdr = (xlog_in_core_2_t *)rhead;
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003998 for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003999 j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
4000 k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
Christoph Hellwigb53e6752007-10-12 10:59:34 +10004001 *(__be32 *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];
Linus Torvalds1da177e2005-04-16 15:20:36 -07004002 dp += BBSIZE;
4003 }
4004 }
Christoph Hellwig0e446be2012-11-12 22:54:24 +11004005
4006 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004007}
4008
4009STATIC int
4010xlog_valid_rec_header(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05004011 struct xlog *log,
4012 struct xlog_rec_header *rhead,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004013 xfs_daddr_t blkno)
4014{
4015 int hlen;
4016
Christoph Hellwig69ef9212011-07-08 14:36:05 +02004017 if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004018 XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
4019 XFS_ERRLEVEL_LOW, log->l_mp);
4020 return XFS_ERROR(EFSCORRUPTED);
4021 }
4022 if (unlikely(
4023 (!rhead->h_version ||
Christoph Hellwigb53e6752007-10-12 10:59:34 +10004024 (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11004025 xfs_warn(log->l_mp, "%s: unrecognised log version (%d).",
Harvey Harrison34a622b2008-04-10 12:19:21 +10004026 __func__, be32_to_cpu(rhead->h_version));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004027 return XFS_ERROR(EIO);
4028 }
4029
4030 /* LR body must have data or it wouldn't have been written */
Christoph Hellwigb53e6752007-10-12 10:59:34 +10004031 hlen = be32_to_cpu(rhead->h_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004032 if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
4033 XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
4034 XFS_ERRLEVEL_LOW, log->l_mp);
4035 return XFS_ERROR(EFSCORRUPTED);
4036 }
4037 if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
4038 XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
4039 XFS_ERRLEVEL_LOW, log->l_mp);
4040 return XFS_ERROR(EFSCORRUPTED);
4041 }
4042 return 0;
4043}
4044
4045/*
4046 * Read the log from tail to head and process the log records found.
4047 * Handle the two cases where the tail and head are in the same cycle
4048 * and where the active portion of the log wraps around the end of
4049 * the physical log separately. The pass parameter is passed through
4050 * to the routines called to process the data and is not looked at
4051 * here.
4052 */
4053STATIC int
4054xlog_do_recovery_pass(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05004055 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004056 xfs_daddr_t head_blk,
4057 xfs_daddr_t tail_blk,
4058 int pass)
4059{
4060 xlog_rec_header_t *rhead;
4061 xfs_daddr_t blk_no;
Andy Polingfc5bc4c2009-11-03 17:26:47 +00004062 xfs_caddr_t offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004063 xfs_buf_t *hbp, *dbp;
4064 int error = 0, h_size;
4065 int bblks, split_bblks;
4066 int hblks, split_hblks, wrapped_hblks;
Dave Chinnerf0a76952010-01-11 11:49:57 +00004067 struct hlist_head rhash[XLOG_RHASH_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -07004068
4069 ASSERT(head_blk != tail_blk);
4070
4071 /*
4072 * Read the header of the tail block and get the iclog buffer size from
4073 * h_size. Use this to tell how many sectors make up the log header.
4074 */
Eric Sandeen62118702008-03-06 13:44:28 +11004075 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004076 /*
4077 * When using variable length iclogs, read first sector of
4078 * iclog header and extract the header size from it. Get a
4079 * new hbp that is the correct size.
4080 */
4081 hbp = xlog_get_bp(log, 1);
4082 if (!hbp)
4083 return ENOMEM;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004084
4085 error = xlog_bread(log, tail_blk, 1, hbp, &offset);
4086 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004087 goto bread_err1;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004088
Linus Torvalds1da177e2005-04-16 15:20:36 -07004089 rhead = (xlog_rec_header_t *)offset;
4090 error = xlog_valid_rec_header(log, rhead, tail_blk);
4091 if (error)
4092 goto bread_err1;
Christoph Hellwigb53e6752007-10-12 10:59:34 +10004093 h_size = be32_to_cpu(rhead->h_size);
4094 if ((be32_to_cpu(rhead->h_version) & XLOG_VERSION_2) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07004095 (h_size > XLOG_HEADER_CYCLE_SIZE)) {
4096 hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
4097 if (h_size % XLOG_HEADER_CYCLE_SIZE)
4098 hblks++;
4099 xlog_put_bp(hbp);
4100 hbp = xlog_get_bp(log, hblks);
4101 } else {
4102 hblks = 1;
4103 }
4104 } else {
Alex Elder69ce58f2010-04-20 17:09:59 +10004105 ASSERT(log->l_sectBBsize == 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004106 hblks = 1;
4107 hbp = xlog_get_bp(log, 1);
4108 h_size = XLOG_BIG_RECORD_BSIZE;
4109 }
4110
4111 if (!hbp)
4112 return ENOMEM;
4113 dbp = xlog_get_bp(log, BTOBB(h_size));
4114 if (!dbp) {
4115 xlog_put_bp(hbp);
4116 return ENOMEM;
4117 }
4118
4119 memset(rhash, 0, sizeof(rhash));
4120 if (tail_blk <= head_blk) {
4121 for (blk_no = tail_blk; blk_no < head_blk; ) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004122 error = xlog_bread(log, blk_no, hblks, hbp, &offset);
4123 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004124 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004125
Linus Torvalds1da177e2005-04-16 15:20:36 -07004126 rhead = (xlog_rec_header_t *)offset;
4127 error = xlog_valid_rec_header(log, rhead, blk_no);
4128 if (error)
4129 goto bread_err2;
4130
4131 /* blocks in data section */
Christoph Hellwigb53e6752007-10-12 10:59:34 +10004132 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004133 error = xlog_bread(log, blk_no + hblks, bblks, dbp,
4134 &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004135 if (error)
4136 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004137
Christoph Hellwig0e446be2012-11-12 22:54:24 +11004138 error = xlog_unpack_data(rhead, offset, log);
4139 if (error)
4140 goto bread_err2;
4141
4142 error = xlog_recover_process_data(log,
4143 rhash, rhead, offset, pass);
4144 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004145 goto bread_err2;
4146 blk_no += bblks + hblks;
4147 }
4148 } else {
4149 /*
4150 * Perform recovery around the end of the physical log.
4151 * When the head is not on the same cycle number as the tail,
4152 * we can't do a sequential recovery as above.
4153 */
4154 blk_no = tail_blk;
4155 while (blk_no < log->l_logBBsize) {
4156 /*
4157 * Check for header wrapping around physical end-of-log
4158 */
Chandra Seetharaman62926042011-07-22 23:40:15 +00004159 offset = hbp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004160 split_hblks = 0;
4161 wrapped_hblks = 0;
4162 if (blk_no + hblks <= log->l_logBBsize) {
4163 /* Read header in one read */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004164 error = xlog_bread(log, blk_no, hblks, hbp,
4165 &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004166 if (error)
4167 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004168 } else {
4169 /* This LR is split across physical log end */
4170 if (blk_no != log->l_logBBsize) {
4171 /* some data before physical log end */
4172 ASSERT(blk_no <= INT_MAX);
4173 split_hblks = log->l_logBBsize - (int)blk_no;
4174 ASSERT(split_hblks > 0);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004175 error = xlog_bread(log, blk_no,
4176 split_hblks, hbp,
4177 &offset);
4178 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004179 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004180 }
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004181
Linus Torvalds1da177e2005-04-16 15:20:36 -07004182 /*
4183 * Note: this black magic still works with
4184 * large sector sizes (non-512) only because:
4185 * - we increased the buffer size originally
4186 * by 1 sector giving us enough extra space
4187 * for the second read;
4188 * - the log start is guaranteed to be sector
4189 * aligned;
4190 * - we read the log end (LR header start)
4191 * _first_, then the log start (LR header end)
4192 * - order is important.
4193 */
David Chinner234f56a2008-04-10 12:24:24 +10004194 wrapped_hblks = hblks - split_hblks;
Dave Chinner44396472011-04-21 09:34:27 +00004195 error = xlog_bread_offset(log, 0,
4196 wrapped_hblks, hbp,
4197 offset + BBTOB(split_hblks));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004198 if (error)
4199 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004200 }
4201 rhead = (xlog_rec_header_t *)offset;
4202 error = xlog_valid_rec_header(log, rhead,
4203 split_hblks ? blk_no : 0);
4204 if (error)
4205 goto bread_err2;
4206
Christoph Hellwigb53e6752007-10-12 10:59:34 +10004207 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004208 blk_no += hblks;
4209
4210 /* Read in data for log record */
4211 if (blk_no + bblks <= log->l_logBBsize) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004212 error = xlog_bread(log, blk_no, bblks, dbp,
4213 &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004214 if (error)
4215 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004216 } else {
4217 /* This log record is split across the
4218 * physical end of log */
Chandra Seetharaman62926042011-07-22 23:40:15 +00004219 offset = dbp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004220 split_bblks = 0;
4221 if (blk_no != log->l_logBBsize) {
4222 /* some data is before the physical
4223 * end of log */
4224 ASSERT(!wrapped_hblks);
4225 ASSERT(blk_no <= INT_MAX);
4226 split_bblks =
4227 log->l_logBBsize - (int)blk_no;
4228 ASSERT(split_bblks > 0);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004229 error = xlog_bread(log, blk_no,
4230 split_bblks, dbp,
4231 &offset);
4232 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004233 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004234 }
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004235
Linus Torvalds1da177e2005-04-16 15:20:36 -07004236 /*
4237 * Note: this black magic still works with
4238 * large sector sizes (non-512) only because:
4239 * - we increased the buffer size originally
4240 * by 1 sector giving us enough extra space
4241 * for the second read;
4242 * - the log start is guaranteed to be sector
4243 * aligned;
4244 * - we read the log end (LR header start)
4245 * _first_, then the log start (LR header end)
4246 * - order is important.
4247 */
Dave Chinner44396472011-04-21 09:34:27 +00004248 error = xlog_bread_offset(log, 0,
Dave Chinner009507b2012-11-02 11:38:44 +11004249 bblks - split_bblks, dbp,
Dave Chinner44396472011-04-21 09:34:27 +00004250 offset + BBTOB(split_bblks));
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004251 if (error)
4252 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004253 }
Christoph Hellwig0e446be2012-11-12 22:54:24 +11004254
4255 error = xlog_unpack_data(rhead, offset, log);
4256 if (error)
4257 goto bread_err2;
4258
4259 error = xlog_recover_process_data(log, rhash,
4260 rhead, offset, pass);
4261 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004262 goto bread_err2;
4263 blk_no += bblks;
4264 }
4265
4266 ASSERT(blk_no >= log->l_logBBsize);
4267 blk_no -= log->l_logBBsize;
4268
4269 /* read first part of physical log */
4270 while (blk_no < head_blk) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004271 error = xlog_bread(log, blk_no, hblks, hbp, &offset);
4272 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004273 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004274
Linus Torvalds1da177e2005-04-16 15:20:36 -07004275 rhead = (xlog_rec_header_t *)offset;
4276 error = xlog_valid_rec_header(log, rhead, blk_no);
4277 if (error)
4278 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004279
Christoph Hellwigb53e6752007-10-12 10:59:34 +10004280 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004281 error = xlog_bread(log, blk_no+hblks, bblks, dbp,
4282 &offset);
4283 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004284 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01004285
Christoph Hellwig0e446be2012-11-12 22:54:24 +11004286 error = xlog_unpack_data(rhead, offset, log);
4287 if (error)
4288 goto bread_err2;
4289
4290 error = xlog_recover_process_data(log, rhash,
4291 rhead, offset, pass);
4292 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004293 goto bread_err2;
4294 blk_no += bblks + hblks;
4295 }
4296 }
4297
4298 bread_err2:
4299 xlog_put_bp(dbp);
4300 bread_err1:
4301 xlog_put_bp(hbp);
4302 return error;
4303}
4304
4305/*
4306 * Do the recovery of the log. We actually do this in two phases.
4307 * The two passes are necessary in order to implement the function
4308 * of cancelling a record written into the log. The first pass
4309 * determines those things which have been cancelled, and the
4310 * second pass replays log items normally except for those which
4311 * have been cancelled. The handling of the replay and cancellations
4312 * takes place in the log item type specific routines.
4313 *
4314 * The table of items which have cancel records in the log is allocated
4315 * and freed at this level, since only here do we know when all of
4316 * the log recovery has been completed.
4317 */
4318STATIC int
4319xlog_do_log_recovery(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05004320 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004321 xfs_daddr_t head_blk,
4322 xfs_daddr_t tail_blk)
4323{
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00004324 int error, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004325
4326 ASSERT(head_blk != tail_blk);
4327
4328 /*
4329 * First do a pass to find all of the cancelled buf log items.
4330 * Store them in the buf_cancel_table for use in the second pass.
4331 */
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00004332 log->l_buf_cancel_table = kmem_zalloc(XLOG_BC_TABLE_SIZE *
4333 sizeof(struct list_head),
Linus Torvalds1da177e2005-04-16 15:20:36 -07004334 KM_SLEEP);
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00004335 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
4336 INIT_LIST_HEAD(&log->l_buf_cancel_table[i]);
4337
Linus Torvalds1da177e2005-04-16 15:20:36 -07004338 error = xlog_do_recovery_pass(log, head_blk, tail_blk,
4339 XLOG_RECOVER_PASS1);
4340 if (error != 0) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10004341 kmem_free(log->l_buf_cancel_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004342 log->l_buf_cancel_table = NULL;
4343 return error;
4344 }
4345 /*
4346 * Then do a second pass to actually recover the items in the log.
4347 * When it is complete free the table of buf cancel items.
4348 */
4349 error = xlog_do_recovery_pass(log, head_blk, tail_blk,
4350 XLOG_RECOVER_PASS2);
4351#ifdef DEBUG
Tim Shimmin6d192a92006-06-09 14:55:38 +10004352 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004353 int i;
4354
4355 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00004356 ASSERT(list_empty(&log->l_buf_cancel_table[i]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004357 }
4358#endif /* DEBUG */
4359
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10004360 kmem_free(log->l_buf_cancel_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004361 log->l_buf_cancel_table = NULL;
4362
4363 return error;
4364}
4365
4366/*
4367 * Do the actual recovery
4368 */
4369STATIC int
4370xlog_do_recover(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05004371 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004372 xfs_daddr_t head_blk,
4373 xfs_daddr_t tail_blk)
4374{
4375 int error;
4376 xfs_buf_t *bp;
4377 xfs_sb_t *sbp;
4378
4379 /*
4380 * First replay the images in the log.
4381 */
4382 error = xlog_do_log_recovery(log, head_blk, tail_blk);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10004383 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004384 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004385
4386 /*
4387 * If IO errors happened during recovery, bail out.
4388 */
4389 if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
4390 return (EIO);
4391 }
4392
4393 /*
4394 * We now update the tail_lsn since much of the recovery has completed
4395 * and there may be space available to use. If there were no extent
4396 * or iunlinks, we can free up the entire log and set the tail_lsn to
4397 * be the last_sync_lsn. This was set in xlog_find_tail to be the
4398 * lsn of the last known good LR on disk. If there are extent frees
4399 * or iunlinks they will have some entries in the AIL; so we look at
4400 * the AIL to determine how to set the tail_lsn.
4401 */
4402 xlog_assign_tail_lsn(log->l_mp);
4403
4404 /*
4405 * Now that we've finished replaying all buffer and inode
Dave Chinner98021822012-11-12 22:54:03 +11004406 * updates, re-read in the superblock and reverify it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004407 */
4408 bp = xfs_getsb(log->l_mp, 0);
4409 XFS_BUF_UNDONE(bp);
Lachlan McIlroybebf9632007-10-15 13:18:02 +10004410 ASSERT(!(XFS_BUF_ISWRITE(bp)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004411 XFS_BUF_READ(bp);
Lachlan McIlroybebf9632007-10-15 13:18:02 +10004412 XFS_BUF_UNASYNC(bp);
Dave Chinner1813dd62012-11-14 17:54:40 +11004413 bp->b_ops = &xfs_sb_buf_ops;
Christoph Hellwig83a0adc2013-12-17 00:03:52 -08004414
4415 if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
4416 xfs_buf_relse(bp);
4417 return XFS_ERROR(EIO);
4418 }
4419
4420 xfs_buf_iorequest(bp);
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +00004421 error = xfs_buf_iowait(bp);
David Chinnerd64e31a2008-04-10 12:22:17 +10004422 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +00004423 xfs_buf_ioerror_alert(bp, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004424 ASSERT(0);
4425 xfs_buf_relse(bp);
4426 return error;
4427 }
4428
4429 /* Convert superblock from on-disk format */
4430 sbp = &log->l_mp->m_sb;
Dave Chinner98021822012-11-12 22:54:03 +11004431 xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004432 ASSERT(sbp->sb_magicnum == XFS_SB_MAGIC);
Eric Sandeen62118702008-03-06 13:44:28 +11004433 ASSERT(xfs_sb_good_version(sbp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004434 xfs_buf_relse(bp);
4435
Lachlan McIlroy5478eea2007-02-10 18:36:29 +11004436 /* We've re-read the superblock so re-initialize per-cpu counters */
4437 xfs_icsb_reinit_counters(log->l_mp);
4438
Linus Torvalds1da177e2005-04-16 15:20:36 -07004439 xlog_recover_check_summary(log);
4440
4441 /* Normal transactions can now occur */
4442 log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
4443 return 0;
4444}
4445
4446/*
4447 * Perform recovery and re-initialize some log variables in xlog_find_tail.
4448 *
4449 * Return error or zero.
4450 */
4451int
4452xlog_recover(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05004453 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004454{
4455 xfs_daddr_t head_blk, tail_blk;
4456 int error;
4457
4458 /* find the tail of the log */
Eric Sandeen65be6052006-01-11 15:34:19 +11004459 if ((error = xlog_find_tail(log, &head_blk, &tail_blk)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004460 return error;
4461
4462 if (tail_blk != head_blk) {
4463 /* There used to be a comment here:
4464 *
4465 * disallow recovery on read-only mounts. note -- mount
4466 * checks for ENOSPC and turns it into an intelligent
4467 * error message.
4468 * ...but this is no longer true. Now, unless you specify
4469 * NORECOVERY (in which case this function would never be
4470 * called), we just go ahead and recover. We do this all
4471 * under the vfs layer, so we can get away with it unless
4472 * the device itself is read-only, in which case we fail.
4473 */
Utako Kusaka3a02ee12007-05-08 13:50:06 +10004474 if ((error = xfs_dev_is_read_only(log->l_mp, "recovery"))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004475 return error;
4476 }
4477
Dave Chinnere721f502013-04-03 16:11:32 +11004478 /*
4479 * Version 5 superblock log feature mask validation. We know the
4480 * log is dirty so check if there are any unknown log features
4481 * in what we need to recover. If there are unknown features
4482 * (e.g. unsupported transactions, then simply reject the
4483 * attempt at recovery before touching anything.
4484 */
4485 if (XFS_SB_VERSION_NUM(&log->l_mp->m_sb) == XFS_SB_VERSION_5 &&
4486 xfs_sb_has_incompat_log_feature(&log->l_mp->m_sb,
4487 XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN)) {
4488 xfs_warn(log->l_mp,
4489"Superblock has unknown incompatible log features (0x%x) enabled.\n"
4490"The log can not be fully and/or safely recovered by this kernel.\n"
4491"Please recover the log on a kernel that supports the unknown features.",
4492 (log->l_mp->m_sb.sb_features_log_incompat &
4493 XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
4494 return EINVAL;
4495 }
4496
Dave Chinnera0fa2b62011-03-07 10:01:35 +11004497 xfs_notice(log->l_mp, "Starting recovery (logdev: %s)",
4498 log->l_mp->m_logname ? log->l_mp->m_logname
4499 : "internal");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004500
4501 error = xlog_do_recover(log, head_blk, tail_blk);
4502 log->l_flags |= XLOG_RECOVERY_NEEDED;
4503 }
4504 return error;
4505}
4506
4507/*
4508 * In the first part of recovery we replay inodes and buffers and build
4509 * up the list of extent free items which need to be processed. Here
4510 * we process the extent free items and clean up the on disk unlinked
4511 * inode lists. This is separated from the first part of recovery so
4512 * that the root and real-time bitmap inodes can be read in from disk in
4513 * between the two stages. This is necessary so that we can free space
4514 * in the real-time portion of the file system.
4515 */
4516int
4517xlog_recover_finish(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05004518 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004519{
4520 /*
4521 * Now we're ready to do the transactions needed for the
4522 * rest of recovery. Start with completing all the extent
4523 * free intent records and then process the unlinked inode
4524 * lists. At this point, we essentially run in normal mode
4525 * except that we're still performing recovery actions
4526 * rather than accepting new requests.
4527 */
4528 if (log->l_flags & XLOG_RECOVERY_NEEDED) {
David Chinner3c1e2bb2008-04-10 12:21:11 +10004529 int error;
4530 error = xlog_recover_process_efis(log);
4531 if (error) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11004532 xfs_alert(log->l_mp, "Failed to recover EFIs");
David Chinner3c1e2bb2008-04-10 12:21:11 +10004533 return error;
4534 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004535 /*
4536 * Sync the log to get all the EFIs out of the AIL.
4537 * This isn't absolutely necessary, but it helps in
4538 * case the unlink transactions would have problems
4539 * pushing the EFIs out of the way.
4540 */
Christoph Hellwiga14a3482010-01-19 09:56:46 +00004541 xfs_log_force(log->l_mp, XFS_LOG_SYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004542
Christoph Hellwig42490232008-08-13 16:49:32 +10004543 xlog_recover_process_iunlinks(log);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004544
4545 xlog_recover_check_summary(log);
4546
Dave Chinnera0fa2b62011-03-07 10:01:35 +11004547 xfs_notice(log->l_mp, "Ending recovery (logdev: %s)",
4548 log->l_mp->m_logname ? log->l_mp->m_logname
4549 : "internal");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004550 log->l_flags &= ~XLOG_RECOVERY_NEEDED;
4551 } else {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11004552 xfs_info(log->l_mp, "Ending clean mount");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004553 }
4554 return 0;
4555}
4556
4557
4558#if defined(DEBUG)
4559/*
4560 * Read all of the agf and agi counters and check that they
4561 * are consistent with the superblock counters.
4562 */
4563void
4564xlog_recover_check_summary(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05004565 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004566{
4567 xfs_mount_t *mp;
4568 xfs_agf_t *agfp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004569 xfs_buf_t *agfbp;
4570 xfs_buf_t *agibp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004571 xfs_agnumber_t agno;
4572 __uint64_t freeblks;
4573 __uint64_t itotal;
4574 __uint64_t ifree;
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11004575 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004576
4577 mp = log->l_mp;
4578
4579 freeblks = 0LL;
4580 itotal = 0LL;
4581 ifree = 0LL;
4582 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
From: Christoph Hellwig48056212008-11-28 14:23:38 +11004583 error = xfs_read_agf(mp, NULL, agno, 0, &agfbp);
4584 if (error) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11004585 xfs_alert(mp, "%s agf read failed agno %d error %d",
4586 __func__, agno, error);
From: Christoph Hellwig48056212008-11-28 14:23:38 +11004587 } else {
4588 agfp = XFS_BUF_TO_AGF(agfbp);
4589 freeblks += be32_to_cpu(agfp->agf_freeblks) +
4590 be32_to_cpu(agfp->agf_flcount);
4591 xfs_buf_relse(agfbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004592 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004593
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11004594 error = xfs_read_agi(mp, NULL, agno, &agibp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11004595 if (error) {
4596 xfs_alert(mp, "%s agi read failed agno %d error %d",
4597 __func__, agno, error);
4598 } else {
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11004599 struct xfs_agi *agi = XFS_BUF_TO_AGI(agibp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004600
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11004601 itotal += be32_to_cpu(agi->agi_count);
4602 ifree += be32_to_cpu(agi->agi_freecount);
4603 xfs_buf_relse(agibp);
4604 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004605 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004606}
4607#endif /* DEBUG */