blob: 15ff5392fb65a601c616c7d30df246d211c70c2b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Tim Shimmin87c199c2006-06-09 14:56:16 +10002 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11003 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_types.h"
Nathan Scotta844f452005-11-02 14:38:42 +110021#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110023#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "xfs_trans.h"
Nathan Scotta844f452005-11-02 14:38:42 +110025#include "xfs_sb.h"
26#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_mount.h"
28#include "xfs_error.h"
29#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110030#include "xfs_alloc_btree.h"
31#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_dinode.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110034#include "xfs_inode_item.h"
Nathan Scotta844f452005-11-02 14:38:42 +110035#include "xfs_alloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_ialloc.h"
37#include "xfs_log_priv.h"
38#include "xfs_buf_item.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "xfs_log_recover.h"
40#include "xfs_extfree_item.h"
41#include "xfs_trans_priv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include "xfs_quota.h"
43#include "xfs_rw.h"
Christoph Hellwig43355092008-03-27 18:01:08 +110044#include "xfs_utils.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000045#include "xfs_trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47STATIC int xlog_find_zeroed(xlog_t *, xfs_daddr_t *);
48STATIC int xlog_clear_stale_blocks(xlog_t *, xfs_lsn_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#if defined(DEBUG)
50STATIC void xlog_recover_check_summary(xlog_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#else
52#define xlog_recover_check_summary(log)
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#endif
54
Linus Torvalds1da177e2005-04-16 15:20:36 -070055/*
Christoph Hellwigd5689ea2010-12-01 22:06:22 +000056 * This structure is used during recovery to record the buf log items which
57 * have been canceled and should not be replayed.
58 */
59struct xfs_buf_cancel {
60 xfs_daddr_t bc_blkno;
61 uint bc_len;
62 int bc_refcount;
63 struct list_head bc_list;
64};
65
66/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 * Sector aligned buffer routines for buffer create/read/write/access
68 */
69
Alex Elderff30a622010-04-13 15:22:58 +100070/*
71 * Verify the given count of basic blocks is valid number of blocks
72 * to specify for an operation involving the given XFS log buffer.
73 * Returns nonzero if the count is valid, 0 otherwise.
74 */
75
76static inline int
77xlog_buf_bbcount_valid(
78 xlog_t *log,
79 int bbcount)
80{
81 return bbcount > 0 && bbcount <= log->l_logBBsize;
82}
83
Alex Elder36adecf2010-04-13 15:21:13 +100084/*
85 * Allocate a buffer to hold log data. The buffer needs to be able
86 * to map to a range of nbblks basic blocks at any valid (basic
87 * block) offset within the log.
88 */
Eric Sandeen5d77c0d2009-11-19 15:52:00 +000089STATIC xfs_buf_t *
Linus Torvalds1da177e2005-04-16 15:20:36 -070090xlog_get_bp(
91 xlog_t *log,
Dave Chinner32281492009-01-22 15:37:47 +110092 int nbblks)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
Christoph Hellwigc8da0fa2011-07-08 14:36:25 +020094 struct xfs_buf *bp;
95
Alex Elderff30a622010-04-13 15:22:58 +100096 if (!xlog_buf_bbcount_valid(log, nbblks)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +110097 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
Alex Elderff30a622010-04-13 15:22:58 +100098 nbblks);
99 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
Dave Chinner32281492009-01-22 15:37:47 +1100100 return NULL;
101 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Alex Elder36adecf2010-04-13 15:21:13 +1000103 /*
104 * We do log I/O in units of log sectors (a power-of-2
105 * multiple of the basic block size), so we round up the
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300106 * requested size to accommodate the basic blocks required
Alex Elder36adecf2010-04-13 15:21:13 +1000107 * for complete log sectors.
108 *
109 * In addition, the buffer may be used for a non-sector-
110 * aligned block offset, in which case an I/O of the
111 * requested size could extend beyond the end of the
112 * buffer. If the requested size is only 1 basic block it
113 * will never straddle a sector boundary, so this won't be
114 * an issue. Nor will this be a problem if the log I/O is
115 * done in basic blocks (sector size 1). But otherwise we
116 * extend the buffer by one extra log sector to ensure
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300117 * there's space to accommodate this possibility.
Alex Elder36adecf2010-04-13 15:21:13 +1000118 */
Alex Elder69ce58f2010-04-20 17:09:59 +1000119 if (nbblks > 1 && log->l_sectBBsize > 1)
120 nbblks += log->l_sectBBsize;
121 nbblks = round_up(nbblks, log->l_sectBBsize);
Alex Elder36adecf2010-04-13 15:21:13 +1000122
Christoph Hellwigc8da0fa2011-07-08 14:36:25 +0200123 bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, BBTOB(nbblks), 0);
124 if (bp)
125 xfs_buf_unlock(bp);
126 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127}
128
Eric Sandeen5d77c0d2009-11-19 15:52:00 +0000129STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130xlog_put_bp(
131 xfs_buf_t *bp)
132{
133 xfs_buf_free(bp);
134}
135
Alex Elder48389ef2010-04-20 17:10:21 +1000136/*
137 * Return the address of the start of the given block number's data
138 * in a log buffer. The buffer covers a log sector-aligned region.
139 */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100140STATIC xfs_caddr_t
141xlog_align(
142 xlog_t *log,
143 xfs_daddr_t blk_no,
144 int nbblks,
145 xfs_buf_t *bp)
146{
Christoph Hellwigfdc07f42010-05-10 17:28:14 +0000147 xfs_daddr_t offset = blk_no & ((xfs_daddr_t)log->l_sectBBsize - 1);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100148
Christoph Hellwigfdc07f42010-05-10 17:28:14 +0000149 ASSERT(BBTOB(offset + nbblks) <= XFS_BUF_SIZE(bp));
Chandra Seetharaman62926042011-07-22 23:40:15 +0000150 return bp->b_addr + BBTOB(offset);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100151}
152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154/*
155 * nbblks should be uint, but oh well. Just want to catch that 32-bit length.
156 */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100157STATIC int
158xlog_bread_noalign(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 xlog_t *log,
160 xfs_daddr_t blk_no,
161 int nbblks,
162 xfs_buf_t *bp)
163{
164 int error;
165
Alex Elderff30a622010-04-13 15:22:58 +1000166 if (!xlog_buf_bbcount_valid(log, nbblks)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100167 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
Alex Elderff30a622010-04-13 15:22:58 +1000168 nbblks);
169 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
Dave Chinner32281492009-01-22 15:37:47 +1100170 return EFSCORRUPTED;
171 }
172
Alex Elder69ce58f2010-04-20 17:09:59 +1000173 blk_no = round_down(blk_no, log->l_sectBBsize);
174 nbblks = round_up(nbblks, log->l_sectBBsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
176 ASSERT(nbblks > 0);
177 ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
179 XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
180 XFS_BUF_READ(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
183 xfsbdstrat(log->l_mp, bp);
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +0000184 error = xfs_buf_iowait(bp);
David Chinnerd64e31a2008-04-10 12:22:17 +1000185 if (error)
Christoph Hellwig901796a2011-10-10 16:52:49 +0000186 xfs_buf_ioerror_alert(bp, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 return error;
188}
189
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100190STATIC int
191xlog_bread(
192 xlog_t *log,
193 xfs_daddr_t blk_no,
194 int nbblks,
195 xfs_buf_t *bp,
196 xfs_caddr_t *offset)
197{
198 int error;
199
200 error = xlog_bread_noalign(log, blk_no, nbblks, bp);
201 if (error)
202 return error;
203
204 *offset = xlog_align(log, blk_no, nbblks, bp);
205 return 0;
206}
207
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208/*
Dave Chinner44396472011-04-21 09:34:27 +0000209 * Read at an offset into the buffer. Returns with the buffer in it's original
210 * state regardless of the result of the read.
211 */
212STATIC int
213xlog_bread_offset(
214 xlog_t *log,
215 xfs_daddr_t blk_no, /* block to read from */
216 int nbblks, /* blocks to read */
217 xfs_buf_t *bp,
218 xfs_caddr_t offset)
219{
Chandra Seetharaman62926042011-07-22 23:40:15 +0000220 xfs_caddr_t orig_offset = bp->b_addr;
Dave Chinner44396472011-04-21 09:34:27 +0000221 int orig_len = bp->b_buffer_length;
222 int error, error2;
223
Chandra Seetharaman02fe03d2011-07-22 23:40:22 +0000224 error = xfs_buf_associate_memory(bp, offset, BBTOB(nbblks));
Dave Chinner44396472011-04-21 09:34:27 +0000225 if (error)
226 return error;
227
228 error = xlog_bread_noalign(log, blk_no, nbblks, bp);
229
230 /* must reset buffer pointer even on error */
Chandra Seetharaman02fe03d2011-07-22 23:40:22 +0000231 error2 = xfs_buf_associate_memory(bp, orig_offset, orig_len);
Dave Chinner44396472011-04-21 09:34:27 +0000232 if (error)
233 return error;
234 return error2;
235}
236
237/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 * Write out the buffer at the given block for the given number of blocks.
239 * The buffer is kept locked across the write and is returned locked.
240 * This can only be used for synchronous log writes.
241 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000242STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243xlog_bwrite(
244 xlog_t *log,
245 xfs_daddr_t blk_no,
246 int nbblks,
247 xfs_buf_t *bp)
248{
249 int error;
250
Alex Elderff30a622010-04-13 15:22:58 +1000251 if (!xlog_buf_bbcount_valid(log, nbblks)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100252 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
Alex Elderff30a622010-04-13 15:22:58 +1000253 nbblks);
254 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
Dave Chinner32281492009-01-22 15:37:47 +1100255 return EFSCORRUPTED;
256 }
257
Alex Elder69ce58f2010-04-20 17:09:59 +1000258 blk_no = round_down(blk_no, log->l_sectBBsize);
259 nbblks = round_up(nbblks, log->l_sectBBsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261 ASSERT(nbblks > 0);
262 ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));
263
264 XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
265 XFS_BUF_ZEROFLAGS(bp);
Chandra Seetharaman72790aa2011-07-22 23:40:04 +0000266 xfs_buf_hold(bp);
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200267 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Christoph Hellwigc2b006c2011-08-23 08:28:07 +0000270 error = xfs_bwrite(bp);
Christoph Hellwig901796a2011-10-10 16:52:49 +0000271 if (error)
272 xfs_buf_ioerror_alert(bp, __func__);
Christoph Hellwigc2b006c2011-08-23 08:28:07 +0000273 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 return error;
275}
276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277#ifdef DEBUG
278/*
279 * dump debug superblock and log record information
280 */
281STATIC void
282xlog_header_check_dump(
283 xfs_mount_t *mp,
284 xlog_rec_header_t *head)
285{
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100286 xfs_debug(mp, "%s: SB : uuid = %pU, fmt = %d\n",
Joe Perches03daa572009-12-14 18:01:10 -0800287 __func__, &mp->m_sb.sb_uuid, XLOG_FMT);
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100288 xfs_debug(mp, " log : uuid = %pU, fmt = %d\n",
Joe Perches03daa572009-12-14 18:01:10 -0800289 &head->h_fs_uuid, be32_to_cpu(head->h_fmt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290}
291#else
292#define xlog_header_check_dump(mp, head)
293#endif
294
295/*
296 * check log record header for recovery
297 */
298STATIC int
299xlog_header_check_recover(
300 xfs_mount_t *mp,
301 xlog_rec_header_t *head)
302{
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200303 ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
305 /*
306 * IRIX doesn't write the h_fmt field and leaves it zeroed
307 * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
308 * a dirty log created in IRIX.
309 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200310 if (unlikely(head->h_fmt != cpu_to_be32(XLOG_FMT))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100311 xfs_warn(mp,
312 "dirty log written in incompatible format - can't recover");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 xlog_header_check_dump(mp, head);
314 XFS_ERROR_REPORT("xlog_header_check_recover(1)",
315 XFS_ERRLEVEL_HIGH, mp);
316 return XFS_ERROR(EFSCORRUPTED);
317 } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100318 xfs_warn(mp,
319 "dirty log entry has mismatched uuid - can't recover");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 xlog_header_check_dump(mp, head);
321 XFS_ERROR_REPORT("xlog_header_check_recover(2)",
322 XFS_ERRLEVEL_HIGH, mp);
323 return XFS_ERROR(EFSCORRUPTED);
324 }
325 return 0;
326}
327
328/*
329 * read the head block of the log and check the header
330 */
331STATIC int
332xlog_header_check_mount(
333 xfs_mount_t *mp,
334 xlog_rec_header_t *head)
335{
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200336 ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
338 if (uuid_is_nil(&head->h_fs_uuid)) {
339 /*
340 * IRIX doesn't write the h_fs_uuid or h_fmt fields. If
341 * h_fs_uuid is nil, we assume this log was last mounted
342 * by IRIX and continue.
343 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100344 xfs_warn(mp, "nil uuid in log - IRIX style log");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100346 xfs_warn(mp, "log has mismatched uuid - can't recover");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 xlog_header_check_dump(mp, head);
348 XFS_ERROR_REPORT("xlog_header_check_mount",
349 XFS_ERRLEVEL_HIGH, mp);
350 return XFS_ERROR(EFSCORRUPTED);
351 }
352 return 0;
353}
354
355STATIC void
356xlog_recover_iodone(
357 struct xfs_buf *bp)
358{
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +0000359 if (bp->b_error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 /*
361 * We're not going to bother about retrying
362 * this during recovery. One strike!
363 */
Christoph Hellwig901796a2011-10-10 16:52:49 +0000364 xfs_buf_ioerror_alert(bp, __func__);
Dave Chinnerebad8612010-09-22 10:47:20 +1000365 xfs_force_shutdown(bp->b_target->bt_mount,
366 SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 }
Christoph Hellwigcb669ca2011-07-13 13:43:49 +0200368 bp->b_iodone = NULL;
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +0000369 xfs_buf_ioend(bp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370}
371
372/*
373 * This routine finds (to an approximation) the first block in the physical
374 * log which contains the given cycle. It uses a binary search algorithm.
375 * Note that the algorithm can not be perfect because the disk will not
376 * necessarily be perfect.
377 */
David Chinnera8272ce2007-11-23 16:28:09 +1100378STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379xlog_find_cycle_start(
380 xlog_t *log,
381 xfs_buf_t *bp,
382 xfs_daddr_t first_blk,
383 xfs_daddr_t *last_blk,
384 uint cycle)
385{
386 xfs_caddr_t offset;
387 xfs_daddr_t mid_blk;
Alex Eldere3bb2e32010-04-15 18:17:30 +0000388 xfs_daddr_t end_blk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 uint mid_cycle;
390 int error;
391
Alex Eldere3bb2e32010-04-15 18:17:30 +0000392 end_blk = *last_blk;
393 mid_blk = BLK_AVG(first_blk, end_blk);
394 while (mid_blk != first_blk && mid_blk != end_blk) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100395 error = xlog_bread(log, mid_blk, 1, bp, &offset);
396 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 return error;
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000398 mid_cycle = xlog_get_cycle(offset);
Alex Eldere3bb2e32010-04-15 18:17:30 +0000399 if (mid_cycle == cycle)
400 end_blk = mid_blk; /* last_half_cycle == mid_cycle */
401 else
402 first_blk = mid_blk; /* first_half_cycle == mid_cycle */
403 mid_blk = BLK_AVG(first_blk, end_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 }
Alex Eldere3bb2e32010-04-15 18:17:30 +0000405 ASSERT((mid_blk == first_blk && mid_blk+1 == end_blk) ||
406 (mid_blk == end_blk && mid_blk-1 == first_blk));
407
408 *last_blk = end_blk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
410 return 0;
411}
412
413/*
Alex Elder3f943d82010-04-15 18:17:34 +0000414 * Check that a range of blocks does not contain stop_on_cycle_no.
415 * Fill in *new_blk with the block offset where such a block is
416 * found, or with -1 (an invalid block number) if there is no such
417 * block in the range. The scan needs to occur from front to back
418 * and the pointer into the region must be updated since a later
419 * routine will need to perform another test.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 */
421STATIC int
422xlog_find_verify_cycle(
423 xlog_t *log,
424 xfs_daddr_t start_blk,
425 int nbblks,
426 uint stop_on_cycle_no,
427 xfs_daddr_t *new_blk)
428{
429 xfs_daddr_t i, j;
430 uint cycle;
431 xfs_buf_t *bp;
432 xfs_daddr_t bufblks;
433 xfs_caddr_t buf = NULL;
434 int error = 0;
435
Alex Elder6881a222010-04-13 15:22:29 +1000436 /*
437 * Greedily allocate a buffer big enough to handle the full
438 * range of basic blocks we'll be examining. If that fails,
439 * try a smaller size. We need to be able to read at least
440 * a log sector, or we're out of luck.
441 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 bufblks = 1 << ffs(nbblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 while (!(bp = xlog_get_bp(log, bufblks))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 bufblks >>= 1;
Alex Elder69ce58f2010-04-20 17:09:59 +1000445 if (bufblks < log->l_sectBBsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 return ENOMEM;
447 }
448
449 for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
450 int bcount;
451
452 bcount = min(bufblks, (start_blk + nbblks - i));
453
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100454 error = xlog_bread(log, i, bcount, bp, &buf);
455 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 goto out;
457
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 for (j = 0; j < bcount; j++) {
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000459 cycle = xlog_get_cycle(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 if (cycle == stop_on_cycle_no) {
461 *new_blk = i+j;
462 goto out;
463 }
464
465 buf += BBSIZE;
466 }
467 }
468
469 *new_blk = -1;
470
471out:
472 xlog_put_bp(bp);
473 return error;
474}
475
476/*
477 * Potentially backup over partial log record write.
478 *
479 * In the typical case, last_blk is the number of the block directly after
480 * a good log record. Therefore, we subtract one to get the block number
481 * of the last block in the given buffer. extra_bblks contains the number
482 * of blocks we would have read on a previous read. This happens when the
483 * last log record is split over the end of the physical log.
484 *
485 * extra_bblks is the number of blocks potentially verified on a previous
486 * call to this routine.
487 */
488STATIC int
489xlog_find_verify_log_record(
490 xlog_t *log,
491 xfs_daddr_t start_blk,
492 xfs_daddr_t *last_blk,
493 int extra_bblks)
494{
495 xfs_daddr_t i;
496 xfs_buf_t *bp;
497 xfs_caddr_t offset = NULL;
498 xlog_rec_header_t *head = NULL;
499 int error = 0;
500 int smallmem = 0;
501 int num_blks = *last_blk - start_blk;
502 int xhdrs;
503
504 ASSERT(start_blk != 0 || *last_blk != start_blk);
505
506 if (!(bp = xlog_get_bp(log, num_blks))) {
507 if (!(bp = xlog_get_bp(log, 1)))
508 return ENOMEM;
509 smallmem = 1;
510 } else {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100511 error = xlog_bread(log, start_blk, num_blks, bp, &offset);
512 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 offset += ((num_blks - 1) << BBSHIFT);
515 }
516
517 for (i = (*last_blk) - 1; i >= 0; i--) {
518 if (i < start_blk) {
519 /* valid log record not found */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100520 xfs_warn(log->l_mp,
521 "Log inconsistent (didn't find previous header)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 ASSERT(0);
523 error = XFS_ERROR(EIO);
524 goto out;
525 }
526
527 if (smallmem) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100528 error = xlog_bread(log, i, 1, bp, &offset);
529 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
532
533 head = (xlog_rec_header_t *)offset;
534
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200535 if (head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 break;
537
538 if (!smallmem)
539 offset -= BBSIZE;
540 }
541
542 /*
543 * We hit the beginning of the physical log & still no header. Return
544 * to caller. If caller can handle a return of -1, then this routine
545 * will be called again for the end of the physical log.
546 */
547 if (i == -1) {
548 error = -1;
549 goto out;
550 }
551
552 /*
553 * We have the final block of the good log (the first block
554 * of the log record _before_ the head. So we check the uuid.
555 */
556 if ((error = xlog_header_check_mount(log->l_mp, head)))
557 goto out;
558
559 /*
560 * We may have found a log record header before we expected one.
561 * last_blk will be the 1st block # with a given cycle #. We may end
562 * up reading an entire log record. In this case, we don't want to
563 * reset last_blk. Only when last_blk points in the middle of a log
564 * record do we update last_blk.
565 */
Eric Sandeen62118702008-03-06 13:44:28 +1100566 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000567 uint h_size = be32_to_cpu(head->h_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
569 xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
570 if (h_size % XLOG_HEADER_CYCLE_SIZE)
571 xhdrs++;
572 } else {
573 xhdrs = 1;
574 }
575
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000576 if (*last_blk - i + extra_bblks !=
577 BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 *last_blk = i;
579
580out:
581 xlog_put_bp(bp);
582 return error;
583}
584
585/*
586 * Head is defined to be the point of the log where the next log write
587 * write could go. This means that incomplete LR writes at the end are
588 * eliminated when calculating the head. We aren't guaranteed that previous
589 * LR have complete transactions. We only know that a cycle number of
590 * current cycle number -1 won't be present in the log if we start writing
591 * from our current block number.
592 *
593 * last_blk contains the block number of the first block with a given
594 * cycle number.
595 *
596 * Return: zero if normal, non-zero if error.
597 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000598STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599xlog_find_head(
600 xlog_t *log,
601 xfs_daddr_t *return_head_blk)
602{
603 xfs_buf_t *bp;
604 xfs_caddr_t offset;
605 xfs_daddr_t new_blk, first_blk, start_blk, last_blk, head_blk;
606 int num_scan_bblks;
607 uint first_half_cycle, last_half_cycle;
608 uint stop_on_cycle;
609 int error, log_bbnum = log->l_logBBsize;
610
611 /* Is the end of the log device zeroed? */
612 if ((error = xlog_find_zeroed(log, &first_blk)) == -1) {
613 *return_head_blk = first_blk;
614
615 /* Is the whole lot zeroed? */
616 if (!first_blk) {
617 /* Linux XFS shouldn't generate totally zeroed logs -
618 * mkfs etc write a dummy unmount record to a fresh
619 * log so we can store the uuid in there
620 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100621 xfs_warn(log->l_mp, "totally zeroed log");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 }
623
624 return 0;
625 } else if (error) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100626 xfs_warn(log->l_mp, "empty log check failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 return error;
628 }
629
630 first_blk = 0; /* get cycle # of 1st block */
631 bp = xlog_get_bp(log, 1);
632 if (!bp)
633 return ENOMEM;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100634
635 error = xlog_bread(log, 0, 1, bp, &offset);
636 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100638
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000639 first_half_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
641 last_blk = head_blk = log_bbnum - 1; /* get cycle # of last block */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100642 error = xlog_bread(log, last_blk, 1, bp, &offset);
643 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100645
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000646 last_half_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 ASSERT(last_half_cycle != 0);
648
649 /*
650 * If the 1st half cycle number is equal to the last half cycle number,
651 * then the entire log is stamped with the same cycle number. In this
652 * case, head_blk can't be set to zero (which makes sense). The below
653 * math doesn't work out properly with head_blk equal to zero. Instead,
654 * we set it to log_bbnum which is an invalid block number, but this
655 * value makes the math correct. If head_blk doesn't changed through
656 * all the tests below, *head_blk is set to zero at the very end rather
657 * than log_bbnum. In a sense, log_bbnum and zero are the same block
658 * in a circular file.
659 */
660 if (first_half_cycle == last_half_cycle) {
661 /*
662 * In this case we believe that the entire log should have
663 * cycle number last_half_cycle. We need to scan backwards
664 * from the end verifying that there are no holes still
665 * containing last_half_cycle - 1. If we find such a hole,
666 * then the start of that hole will be the new head. The
667 * simple case looks like
668 * x | x ... | x - 1 | x
669 * Another case that fits this picture would be
670 * x | x + 1 | x ... | x
Nathan Scottc41564b2006-03-29 08:55:14 +1000671 * In this case the head really is somewhere at the end of the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 * log, as one of the latest writes at the beginning was
673 * incomplete.
674 * One more case is
675 * x | x + 1 | x ... | x - 1 | x
676 * This is really the combination of the above two cases, and
677 * the head has to end up at the start of the x-1 hole at the
678 * end of the log.
679 *
680 * In the 256k log case, we will read from the beginning to the
681 * end of the log and search for cycle numbers equal to x-1.
682 * We don't worry about the x+1 blocks that we encounter,
683 * because we know that they cannot be the head since the log
684 * started with x.
685 */
686 head_blk = log_bbnum;
687 stop_on_cycle = last_half_cycle - 1;
688 } else {
689 /*
690 * In this case we want to find the first block with cycle
691 * number matching last_half_cycle. We expect the log to be
692 * some variation on
Alex Elder3f943d82010-04-15 18:17:34 +0000693 * x + 1 ... | x ... | x
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 * The first block with cycle number x (last_half_cycle) will
695 * be where the new head belongs. First we do a binary search
696 * for the first occurrence of last_half_cycle. The binary
697 * search may not be totally accurate, so then we scan back
698 * from there looking for occurrences of last_half_cycle before
699 * us. If that backwards scan wraps around the beginning of
700 * the log, then we look for occurrences of last_half_cycle - 1
701 * at the end of the log. The cases we're looking for look
702 * like
Alex Elder3f943d82010-04-15 18:17:34 +0000703 * v binary search stopped here
704 * x + 1 ... | x | x + 1 | x ... | x
705 * ^ but we want to locate this spot
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 * or
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 * <---------> less than scan distance
Alex Elder3f943d82010-04-15 18:17:34 +0000708 * x + 1 ... | x ... | x - 1 | x
709 * ^ we want to locate this spot
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 */
711 stop_on_cycle = last_half_cycle;
712 if ((error = xlog_find_cycle_start(log, bp, first_blk,
713 &head_blk, last_half_cycle)))
714 goto bp_err;
715 }
716
717 /*
718 * Now validate the answer. Scan back some number of maximum possible
719 * blocks and make sure each one has the expected cycle number. The
720 * maximum is determined by the total possible amount of buffering
721 * in the in-core log. The following number can be made tighter if
722 * we actually look at the block size of the filesystem.
723 */
724 num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
725 if (head_blk >= num_scan_bblks) {
726 /*
727 * We are guaranteed that the entire check can be performed
728 * in one buffer.
729 */
730 start_blk = head_blk - num_scan_bblks;
731 if ((error = xlog_find_verify_cycle(log,
732 start_blk, num_scan_bblks,
733 stop_on_cycle, &new_blk)))
734 goto bp_err;
735 if (new_blk != -1)
736 head_blk = new_blk;
737 } else { /* need to read 2 parts of log */
738 /*
739 * We are going to scan backwards in the log in two parts.
740 * First we scan the physical end of the log. In this part
741 * of the log, we are looking for blocks with cycle number
742 * last_half_cycle - 1.
743 * If we find one, then we know that the log starts there, as
744 * we've found a hole that didn't get written in going around
745 * the end of the physical log. The simple case for this is
746 * x + 1 ... | x ... | x - 1 | x
747 * <---------> less than scan distance
748 * If all of the blocks at the end of the log have cycle number
749 * last_half_cycle, then we check the blocks at the start of
750 * the log looking for occurrences of last_half_cycle. If we
751 * find one, then our current estimate for the location of the
752 * first occurrence of last_half_cycle is wrong and we move
753 * back to the hole we've found. This case looks like
754 * x + 1 ... | x | x + 1 | x ...
755 * ^ binary search stopped here
756 * Another case we need to handle that only occurs in 256k
757 * logs is
758 * x + 1 ... | x ... | x+1 | x ...
759 * ^ binary search stops here
760 * In a 256k log, the scan at the end of the log will see the
761 * x + 1 blocks. We need to skip past those since that is
762 * certainly not the head of the log. By searching for
763 * last_half_cycle-1 we accomplish that.
764 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 ASSERT(head_blk <= INT_MAX &&
Alex Elder3f943d82010-04-15 18:17:34 +0000766 (xfs_daddr_t) num_scan_bblks >= head_blk);
767 start_blk = log_bbnum - (num_scan_bblks - head_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 if ((error = xlog_find_verify_cycle(log, start_blk,
769 num_scan_bblks - (int)head_blk,
770 (stop_on_cycle - 1), &new_blk)))
771 goto bp_err;
772 if (new_blk != -1) {
773 head_blk = new_blk;
Alex Elder9db127e2010-04-15 18:17:26 +0000774 goto validate_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 }
776
777 /*
778 * Scan beginning of log now. The last part of the physical
779 * log is good. This scan needs to verify that it doesn't find
780 * the last_half_cycle.
781 */
782 start_blk = 0;
783 ASSERT(head_blk <= INT_MAX);
784 if ((error = xlog_find_verify_cycle(log,
785 start_blk, (int)head_blk,
786 stop_on_cycle, &new_blk)))
787 goto bp_err;
788 if (new_blk != -1)
789 head_blk = new_blk;
790 }
791
Alex Elder9db127e2010-04-15 18:17:26 +0000792validate_head:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 /*
794 * Now we need to make sure head_blk is not pointing to a block in
795 * the middle of a log record.
796 */
797 num_scan_bblks = XLOG_REC_SHIFT(log);
798 if (head_blk >= num_scan_bblks) {
799 start_blk = head_blk - num_scan_bblks; /* don't read head_blk */
800
801 /* start ptr at last block ptr before head_blk */
802 if ((error = xlog_find_verify_log_record(log, start_blk,
803 &head_blk, 0)) == -1) {
804 error = XFS_ERROR(EIO);
805 goto bp_err;
806 } else if (error)
807 goto bp_err;
808 } else {
809 start_blk = 0;
810 ASSERT(head_blk <= INT_MAX);
811 if ((error = xlog_find_verify_log_record(log, start_blk,
812 &head_blk, 0)) == -1) {
813 /* We hit the beginning of the log during our search */
Alex Elder3f943d82010-04-15 18:17:34 +0000814 start_blk = log_bbnum - (num_scan_bblks - head_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 new_blk = log_bbnum;
816 ASSERT(start_blk <= INT_MAX &&
817 (xfs_daddr_t) log_bbnum-start_blk >= 0);
818 ASSERT(head_blk <= INT_MAX);
819 if ((error = xlog_find_verify_log_record(log,
820 start_blk, &new_blk,
821 (int)head_blk)) == -1) {
822 error = XFS_ERROR(EIO);
823 goto bp_err;
824 } else if (error)
825 goto bp_err;
826 if (new_blk != log_bbnum)
827 head_blk = new_blk;
828 } else if (error)
829 goto bp_err;
830 }
831
832 xlog_put_bp(bp);
833 if (head_blk == log_bbnum)
834 *return_head_blk = 0;
835 else
836 *return_head_blk = head_blk;
837 /*
838 * When returning here, we have a good block number. Bad block
839 * means that during a previous crash, we didn't have a clean break
840 * from cycle number N to cycle number N-1. In this case, we need
841 * to find the first block with cycle number N-1.
842 */
843 return 0;
844
845 bp_err:
846 xlog_put_bp(bp);
847
848 if (error)
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100849 xfs_warn(log->l_mp, "failed to find log head");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 return error;
851}
852
853/*
854 * Find the sync block number or the tail of the log.
855 *
856 * This will be the block number of the last record to have its
857 * associated buffers synced to disk. Every log record header has
858 * a sync lsn embedded in it. LSNs hold block numbers, so it is easy
859 * to get a sync block number. The only concern is to figure out which
860 * log record header to believe.
861 *
862 * The following algorithm uses the log record header with the largest
863 * lsn. The entire log record does not need to be valid. We only care
864 * that the header is valid.
865 *
866 * We could speed up search by using current head_blk buffer, but it is not
867 * available.
868 */
Eric Sandeen5d77c0d2009-11-19 15:52:00 +0000869STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870xlog_find_tail(
871 xlog_t *log,
872 xfs_daddr_t *head_blk,
Eric Sandeen65be6052006-01-11 15:34:19 +1100873 xfs_daddr_t *tail_blk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874{
875 xlog_rec_header_t *rhead;
876 xlog_op_header_t *op_head;
877 xfs_caddr_t offset = NULL;
878 xfs_buf_t *bp;
879 int error, i, found;
880 xfs_daddr_t umount_data_blk;
881 xfs_daddr_t after_umount_blk;
882 xfs_lsn_t tail_lsn;
883 int hblks;
884
885 found = 0;
886
887 /*
888 * Find previous log record
889 */
890 if ((error = xlog_find_head(log, head_blk)))
891 return error;
892
893 bp = xlog_get_bp(log, 1);
894 if (!bp)
895 return ENOMEM;
896 if (*head_blk == 0) { /* special case */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100897 error = xlog_bread(log, 0, 1, bp, &offset);
898 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +0000899 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100900
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000901 if (xlog_get_cycle(offset) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 *tail_blk = 0;
903 /* leave all other log inited values alone */
Alex Elder9db127e2010-04-15 18:17:26 +0000904 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 }
906 }
907
908 /*
909 * Search backwards looking for log record header block
910 */
911 ASSERT(*head_blk < INT_MAX);
912 for (i = (int)(*head_blk) - 1; i >= 0; i--) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100913 error = xlog_bread(log, i, 1, bp, &offset);
914 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +0000915 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100916
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200917 if (*(__be32 *)offset == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 found = 1;
919 break;
920 }
921 }
922 /*
923 * If we haven't found the log record header block, start looking
924 * again from the end of the physical log. XXXmiken: There should be
925 * a check here to make sure we didn't search more than N blocks in
926 * the previous code.
927 */
928 if (!found) {
929 for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100930 error = xlog_bread(log, i, 1, bp, &offset);
931 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +0000932 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100933
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200934 if (*(__be32 *)offset ==
935 cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 found = 2;
937 break;
938 }
939 }
940 }
941 if (!found) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100942 xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 ASSERT(0);
944 return XFS_ERROR(EIO);
945 }
946
947 /* find blk_no of tail of log */
948 rhead = (xlog_rec_header_t *)offset;
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000949 *tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
951 /*
952 * Reset log values according to the state of the log when we
953 * crashed. In the case where head_blk == 0, we bump curr_cycle
954 * one because the next write starts a new cycle rather than
955 * continuing the cycle of the last good log record. At this
956 * point we have guaranteed that all partial log records have been
957 * accounted for. Therefore, we know that the last good log record
958 * written was complete and ended exactly on the end boundary
959 * of the physical log.
960 */
961 log->l_prev_block = i;
962 log->l_curr_block = (int)*head_blk;
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000963 log->l_curr_cycle = be32_to_cpu(rhead->h_cycle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 if (found == 2)
965 log->l_curr_cycle++;
Dave Chinner1c3cb9e2010-12-21 12:28:39 +1100966 atomic64_set(&log->l_tail_lsn, be64_to_cpu(rhead->h_tail_lsn));
Dave Chinner84f3c682010-12-03 22:11:29 +1100967 atomic64_set(&log->l_last_sync_lsn, be64_to_cpu(rhead->h_lsn));
Dave Chinnera69ed032010-12-21 12:08:20 +1100968 xlog_assign_grant_head(&log->l_grant_reserve_head, log->l_curr_cycle,
969 BBTOB(log->l_curr_block));
970 xlog_assign_grant_head(&log->l_grant_write_head, log->l_curr_cycle,
971 BBTOB(log->l_curr_block));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
973 /*
974 * Look for unmount record. If we find it, then we know there
975 * was a clean unmount. Since 'i' could be the last block in
976 * the physical log, we convert to a log block before comparing
977 * to the head_blk.
978 *
979 * Save the current tail lsn to use to pass to
980 * xlog_clear_stale_blocks() below. We won't want to clear the
981 * unmount record if there is one, so we pass the lsn of the
982 * unmount record rather than the block after it.
983 */
Eric Sandeen62118702008-03-06 13:44:28 +1100984 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000985 int h_size = be32_to_cpu(rhead->h_size);
986 int h_version = be32_to_cpu(rhead->h_version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987
988 if ((h_version & XLOG_VERSION_2) &&
989 (h_size > XLOG_HEADER_CYCLE_SIZE)) {
990 hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
991 if (h_size % XLOG_HEADER_CYCLE_SIZE)
992 hblks++;
993 } else {
994 hblks = 1;
995 }
996 } else {
997 hblks = 1;
998 }
999 after_umount_blk = (i + hblks + (int)
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001000 BTOBB(be32_to_cpu(rhead->h_len))) % log->l_logBBsize;
Dave Chinner1c3cb9e2010-12-21 12:28:39 +11001001 tail_lsn = atomic64_read(&log->l_tail_lsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 if (*head_blk == after_umount_blk &&
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001003 be32_to_cpu(rhead->h_num_logops) == 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 umount_data_blk = (i + hblks) % log->l_logBBsize;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001005 error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
1006 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +00001007 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 op_head = (xlog_op_header_t *)offset;
1010 if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
1011 /*
1012 * Set tail and last sync so that newly written
1013 * log records will point recovery to after the
1014 * current unmount record.
1015 */
Dave Chinner1c3cb9e2010-12-21 12:28:39 +11001016 xlog_assign_atomic_lsn(&log->l_tail_lsn,
1017 log->l_curr_cycle, after_umount_blk);
1018 xlog_assign_atomic_lsn(&log->l_last_sync_lsn,
1019 log->l_curr_cycle, after_umount_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 *tail_blk = after_umount_blk;
David Chinner92821e22007-05-24 15:26:31 +10001021
1022 /*
1023 * Note that the unmount was clean. If the unmount
1024 * was not clean, we need to know this to rebuild the
1025 * superblock counters from the perag headers if we
1026 * have a filesystem using non-persistent counters.
1027 */
1028 log->l_mp->m_flags |= XFS_MOUNT_WAS_CLEAN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 }
1030 }
1031
1032 /*
1033 * Make sure that there are no blocks in front of the head
1034 * with the same cycle number as the head. This can happen
1035 * because we allow multiple outstanding log writes concurrently,
1036 * and the later writes might make it out before earlier ones.
1037 *
1038 * We use the lsn from before modifying it so that we'll never
1039 * overwrite the unmount record after a clean unmount.
1040 *
1041 * Do this only if we are going to recover the filesystem
1042 *
1043 * NOTE: This used to say "if (!readonly)"
1044 * However on Linux, we can & do recover a read-only filesystem.
1045 * We only skip recovery if NORECOVERY is specified on mount,
1046 * in which case we would not be here.
1047 *
1048 * But... if the -device- itself is readonly, just skip this.
1049 * We can't recover this device anyway, so it won't matter.
1050 */
Alex Elder9db127e2010-04-15 18:17:26 +00001051 if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 error = xlog_clear_stale_blocks(log, tail_lsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
Alex Elder9db127e2010-04-15 18:17:26 +00001054done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 xlog_put_bp(bp);
1056
1057 if (error)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001058 xfs_warn(log->l_mp, "failed to locate log tail");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 return error;
1060}
1061
1062/*
1063 * Is the log zeroed at all?
1064 *
1065 * The last binary search should be changed to perform an X block read
1066 * once X becomes small enough. You can then search linearly through
1067 * the X blocks. This will cut down on the number of reads we need to do.
1068 *
1069 * If the log is partially zeroed, this routine will pass back the blkno
1070 * of the first block with cycle number 0. It won't have a complete LR
1071 * preceding it.
1072 *
1073 * Return:
1074 * 0 => the log is completely written to
1075 * -1 => use *blk_no as the first block of the log
1076 * >0 => error has occurred
1077 */
David Chinnera8272ce2007-11-23 16:28:09 +11001078STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079xlog_find_zeroed(
1080 xlog_t *log,
1081 xfs_daddr_t *blk_no)
1082{
1083 xfs_buf_t *bp;
1084 xfs_caddr_t offset;
1085 uint first_cycle, last_cycle;
1086 xfs_daddr_t new_blk, last_blk, start_blk;
1087 xfs_daddr_t num_scan_bblks;
1088 int error, log_bbnum = log->l_logBBsize;
1089
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10001090 *blk_no = 0;
1091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 /* check totally zeroed log */
1093 bp = xlog_get_bp(log, 1);
1094 if (!bp)
1095 return ENOMEM;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001096 error = xlog_bread(log, 0, 1, bp, &offset);
1097 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001099
Christoph Hellwig03bea6f2007-10-12 10:58:05 +10001100 first_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 if (first_cycle == 0) { /* completely zeroed log */
1102 *blk_no = 0;
1103 xlog_put_bp(bp);
1104 return -1;
1105 }
1106
1107 /* check partially zeroed log */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001108 error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
1109 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001111
Christoph Hellwig03bea6f2007-10-12 10:58:05 +10001112 last_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 if (last_cycle != 0) { /* log completely written to */
1114 xlog_put_bp(bp);
1115 return 0;
1116 } else if (first_cycle != 1) {
1117 /*
1118 * If the cycle of the last block is zero, the cycle of
1119 * the first block must be 1. If it's not, maybe we're
1120 * not looking at a log... Bail out.
1121 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001122 xfs_warn(log->l_mp,
1123 "Log inconsistent or not a log (last==0, first!=1)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 return XFS_ERROR(EINVAL);
1125 }
1126
1127 /* we have a partially zeroed log */
1128 last_blk = log_bbnum-1;
1129 if ((error = xlog_find_cycle_start(log, bp, 0, &last_blk, 0)))
1130 goto bp_err;
1131
1132 /*
1133 * Validate the answer. Because there is no way to guarantee that
1134 * the entire log is made up of log records which are the same size,
1135 * we scan over the defined maximum blocks. At this point, the maximum
1136 * is not chosen to mean anything special. XXXmiken
1137 */
1138 num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
1139 ASSERT(num_scan_bblks <= INT_MAX);
1140
1141 if (last_blk < num_scan_bblks)
1142 num_scan_bblks = last_blk;
1143 start_blk = last_blk - num_scan_bblks;
1144
1145 /*
1146 * We search for any instances of cycle number 0 that occur before
1147 * our current estimate of the head. What we're trying to detect is
1148 * 1 ... | 0 | 1 | 0...
1149 * ^ binary search ends here
1150 */
1151 if ((error = xlog_find_verify_cycle(log, start_blk,
1152 (int)num_scan_bblks, 0, &new_blk)))
1153 goto bp_err;
1154 if (new_blk != -1)
1155 last_blk = new_blk;
1156
1157 /*
1158 * Potentially backup over partial log record write. We don't need
1159 * to search the end of the log because we know it is zero.
1160 */
1161 if ((error = xlog_find_verify_log_record(log, start_blk,
1162 &last_blk, 0)) == -1) {
1163 error = XFS_ERROR(EIO);
1164 goto bp_err;
1165 } else if (error)
1166 goto bp_err;
1167
1168 *blk_no = last_blk;
1169bp_err:
1170 xlog_put_bp(bp);
1171 if (error)
1172 return error;
1173 return -1;
1174}
1175
1176/*
1177 * These are simple subroutines used by xlog_clear_stale_blocks() below
1178 * to initialize a buffer full of empty log record headers and write
1179 * them into the log.
1180 */
1181STATIC void
1182xlog_add_record(
1183 xlog_t *log,
1184 xfs_caddr_t buf,
1185 int cycle,
1186 int block,
1187 int tail_cycle,
1188 int tail_block)
1189{
1190 xlog_rec_header_t *recp = (xlog_rec_header_t *)buf;
1191
1192 memset(buf, 0, BBSIZE);
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001193 recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
1194 recp->h_cycle = cpu_to_be32(cycle);
1195 recp->h_version = cpu_to_be32(
Eric Sandeen62118702008-03-06 13:44:28 +11001196 xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001197 recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block));
1198 recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block));
1199 recp->h_fmt = cpu_to_be32(XLOG_FMT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
1201}
1202
1203STATIC int
1204xlog_write_log_records(
1205 xlog_t *log,
1206 int cycle,
1207 int start_block,
1208 int blocks,
1209 int tail_cycle,
1210 int tail_block)
1211{
1212 xfs_caddr_t offset;
1213 xfs_buf_t *bp;
1214 int balign, ealign;
Alex Elder69ce58f2010-04-20 17:09:59 +10001215 int sectbb = log->l_sectBBsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 int end_block = start_block + blocks;
1217 int bufblks;
1218 int error = 0;
1219 int i, j = 0;
1220
Alex Elder6881a222010-04-13 15:22:29 +10001221 /*
1222 * Greedily allocate a buffer big enough to handle the full
1223 * range of basic blocks to be written. If that fails, try
1224 * a smaller size. We need to be able to write at least a
1225 * log sector, or we're out of luck.
1226 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 bufblks = 1 << ffs(blocks);
1228 while (!(bp = xlog_get_bp(log, bufblks))) {
1229 bufblks >>= 1;
Alex Elder69ce58f2010-04-20 17:09:59 +10001230 if (bufblks < sectbb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 return ENOMEM;
1232 }
1233
1234 /* We may need to do a read at the start to fill in part of
1235 * the buffer in the starting sector not covered by the first
1236 * write below.
1237 */
Alex Elder5c17f532010-04-13 15:22:48 +10001238 balign = round_down(start_block, sectbb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 if (balign != start_block) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001240 error = xlog_bread_noalign(log, start_block, 1, bp);
1241 if (error)
1242 goto out_put_bp;
1243
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 j = start_block - balign;
1245 }
1246
1247 for (i = start_block; i < end_block; i += bufblks) {
1248 int bcount, endcount;
1249
1250 bcount = min(bufblks, end_block - start_block);
1251 endcount = bcount - j;
1252
1253 /* We may need to do a read at the end to fill in part of
1254 * the buffer in the final sector not covered by the write.
1255 * If this is the same sector as the above read, skip it.
1256 */
Alex Elder5c17f532010-04-13 15:22:48 +10001257 ealign = round_down(end_block, sectbb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 if (j == 0 && (start_block + endcount > ealign)) {
Chandra Seetharaman62926042011-07-22 23:40:15 +00001259 offset = bp->b_addr + BBTOB(ealign - start_block);
Dave Chinner44396472011-04-21 09:34:27 +00001260 error = xlog_bread_offset(log, ealign, sectbb,
1261 bp, offset);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001262 if (error)
1263 break;
1264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 }
1266
1267 offset = xlog_align(log, start_block, endcount, bp);
1268 for (; j < endcount; j++) {
1269 xlog_add_record(log, offset, cycle, i+j,
1270 tail_cycle, tail_block);
1271 offset += BBSIZE;
1272 }
1273 error = xlog_bwrite(log, start_block, endcount, bp);
1274 if (error)
1275 break;
1276 start_block += endcount;
1277 j = 0;
1278 }
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001279
1280 out_put_bp:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 xlog_put_bp(bp);
1282 return error;
1283}
1284
1285/*
1286 * This routine is called to blow away any incomplete log writes out
1287 * in front of the log head. We do this so that we won't become confused
1288 * if we come up, write only a little bit more, and then crash again.
1289 * If we leave the partial log records out there, this situation could
1290 * cause us to think those partial writes are valid blocks since they
1291 * have the current cycle number. We get rid of them by overwriting them
1292 * with empty log records with the old cycle number rather than the
1293 * current one.
1294 *
1295 * The tail lsn is passed in rather than taken from
1296 * the log so that we will not write over the unmount record after a
1297 * clean unmount in a 512 block log. Doing so would leave the log without
1298 * any valid log records in it until a new one was written. If we crashed
1299 * during that time we would not be able to recover.
1300 */
1301STATIC int
1302xlog_clear_stale_blocks(
1303 xlog_t *log,
1304 xfs_lsn_t tail_lsn)
1305{
1306 int tail_cycle, head_cycle;
1307 int tail_block, head_block;
1308 int tail_distance, max_distance;
1309 int distance;
1310 int error;
1311
1312 tail_cycle = CYCLE_LSN(tail_lsn);
1313 tail_block = BLOCK_LSN(tail_lsn);
1314 head_cycle = log->l_curr_cycle;
1315 head_block = log->l_curr_block;
1316
1317 /*
1318 * Figure out the distance between the new head of the log
1319 * and the tail. We want to write over any blocks beyond the
1320 * head that we may have written just before the crash, but
1321 * we don't want to overwrite the tail of the log.
1322 */
1323 if (head_cycle == tail_cycle) {
1324 /*
1325 * The tail is behind the head in the physical log,
1326 * so the distance from the head to the tail is the
1327 * distance from the head to the end of the log plus
1328 * the distance from the beginning of the log to the
1329 * tail.
1330 */
1331 if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
1332 XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
1333 XFS_ERRLEVEL_LOW, log->l_mp);
1334 return XFS_ERROR(EFSCORRUPTED);
1335 }
1336 tail_distance = tail_block + (log->l_logBBsize - head_block);
1337 } else {
1338 /*
1339 * The head is behind the tail in the physical log,
1340 * so the distance from the head to the tail is just
1341 * the tail block minus the head block.
1342 */
1343 if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
1344 XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
1345 XFS_ERRLEVEL_LOW, log->l_mp);
1346 return XFS_ERROR(EFSCORRUPTED);
1347 }
1348 tail_distance = tail_block - head_block;
1349 }
1350
1351 /*
1352 * If the head is right up against the tail, we can't clear
1353 * anything.
1354 */
1355 if (tail_distance <= 0) {
1356 ASSERT(tail_distance == 0);
1357 return 0;
1358 }
1359
1360 max_distance = XLOG_TOTAL_REC_SHIFT(log);
1361 /*
1362 * Take the smaller of the maximum amount of outstanding I/O
1363 * we could have and the distance to the tail to clear out.
1364 * We take the smaller so that we don't overwrite the tail and
1365 * we don't waste all day writing from the head to the tail
1366 * for no reason.
1367 */
1368 max_distance = MIN(max_distance, tail_distance);
1369
1370 if ((head_block + max_distance) <= log->l_logBBsize) {
1371 /*
1372 * We can stomp all the blocks we need to without
1373 * wrapping around the end of the log. Just do it
1374 * in a single write. Use the cycle number of the
1375 * current cycle minus one so that the log will look like:
1376 * n ... | n - 1 ...
1377 */
1378 error = xlog_write_log_records(log, (head_cycle - 1),
1379 head_block, max_distance, tail_cycle,
1380 tail_block);
1381 if (error)
1382 return error;
1383 } else {
1384 /*
1385 * We need to wrap around the end of the physical log in
1386 * order to clear all the blocks. Do it in two separate
1387 * I/Os. The first write should be from the head to the
1388 * end of the physical log, and it should use the current
1389 * cycle number minus one just like above.
1390 */
1391 distance = log->l_logBBsize - head_block;
1392 error = xlog_write_log_records(log, (head_cycle - 1),
1393 head_block, distance, tail_cycle,
1394 tail_block);
1395
1396 if (error)
1397 return error;
1398
1399 /*
1400 * Now write the blocks at the start of the physical log.
1401 * This writes the remainder of the blocks we want to clear.
1402 * It uses the current cycle number since we're now on the
1403 * same cycle as the head so that we get:
1404 * n ... n ... | n - 1 ...
1405 * ^^^^^ blocks we're writing
1406 */
1407 distance = max_distance - (log->l_logBBsize - head_block);
1408 error = xlog_write_log_records(log, head_cycle, 0, distance,
1409 tail_cycle, tail_block);
1410 if (error)
1411 return error;
1412 }
1413
1414 return 0;
1415}
1416
1417/******************************************************************************
1418 *
1419 * Log recover routines
1420 *
1421 ******************************************************************************
1422 */
1423
1424STATIC xlog_recover_t *
1425xlog_recover_find_tid(
Dave Chinnerf0a76952010-01-11 11:49:57 +00001426 struct hlist_head *head,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 xlog_tid_t tid)
1428{
Dave Chinnerf0a76952010-01-11 11:49:57 +00001429 xlog_recover_t *trans;
1430 struct hlist_node *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
Dave Chinnerf0a76952010-01-11 11:49:57 +00001432 hlist_for_each_entry(trans, n, head, r_list) {
1433 if (trans->r_log_tid == tid)
1434 return trans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 }
Dave Chinnerf0a76952010-01-11 11:49:57 +00001436 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437}
1438
1439STATIC void
Dave Chinnerf0a76952010-01-11 11:49:57 +00001440xlog_recover_new_tid(
1441 struct hlist_head *head,
1442 xlog_tid_t tid,
1443 xfs_lsn_t lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444{
Dave Chinnerf0a76952010-01-11 11:49:57 +00001445 xlog_recover_t *trans;
1446
1447 trans = kmem_zalloc(sizeof(xlog_recover_t), KM_SLEEP);
1448 trans->r_log_tid = tid;
1449 trans->r_lsn = lsn;
1450 INIT_LIST_HEAD(&trans->r_itemq);
1451
1452 INIT_HLIST_NODE(&trans->r_list);
1453 hlist_add_head(&trans->r_list, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454}
1455
1456STATIC void
1457xlog_recover_add_item(
Dave Chinnerf0a76952010-01-11 11:49:57 +00001458 struct list_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459{
1460 xlog_recover_item_t *item;
1461
1462 item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
Dave Chinnerf0a76952010-01-11 11:49:57 +00001463 INIT_LIST_HEAD(&item->ri_list);
1464 list_add_tail(&item->ri_list, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465}
1466
1467STATIC int
1468xlog_recover_add_to_cont_trans(
Dave Chinner9abbc532010-04-13 15:06:46 +10001469 struct log *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 xlog_recover_t *trans,
1471 xfs_caddr_t dp,
1472 int len)
1473{
1474 xlog_recover_item_t *item;
1475 xfs_caddr_t ptr, old_ptr;
1476 int old_len;
1477
Dave Chinnerf0a76952010-01-11 11:49:57 +00001478 if (list_empty(&trans->r_itemq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 /* finish copying rest of trans header */
1480 xlog_recover_add_item(&trans->r_itemq);
1481 ptr = (xfs_caddr_t) &trans->r_theader +
1482 sizeof(xfs_trans_header_t) - len;
1483 memcpy(ptr, dp, len); /* d, s, l */
1484 return 0;
1485 }
Dave Chinnerf0a76952010-01-11 11:49:57 +00001486 /* take the tail entry */
1487 item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488
1489 old_ptr = item->ri_buf[item->ri_cnt-1].i_addr;
1490 old_len = item->ri_buf[item->ri_cnt-1].i_len;
1491
Mitsuo Hayasaka45053602012-01-27 06:37:26 +00001492 ptr = kmem_realloc(old_ptr, len+old_len, old_len, KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 memcpy(&ptr[old_len], dp, len); /* d, s, l */
1494 item->ri_buf[item->ri_cnt-1].i_len += len;
1495 item->ri_buf[item->ri_cnt-1].i_addr = ptr;
Dave Chinner9abbc532010-04-13 15:06:46 +10001496 trace_xfs_log_recover_item_add_cont(log, trans, item, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 return 0;
1498}
1499
1500/*
1501 * The next region to add is the start of a new region. It could be
1502 * a whole region or it could be the first part of a new region. Because
1503 * of this, the assumption here is that the type and size fields of all
1504 * format structures fit into the first 32 bits of the structure.
1505 *
1506 * This works because all regions must be 32 bit aligned. Therefore, we
1507 * either have both fields or we have neither field. In the case we have
1508 * neither field, the data part of the region is zero length. We only have
1509 * a log_op_header and can throw away the header since a new one will appear
1510 * later. If we have at least 4 bytes, then we can determine how many regions
1511 * will appear in the current log item.
1512 */
1513STATIC int
1514xlog_recover_add_to_trans(
Dave Chinner9abbc532010-04-13 15:06:46 +10001515 struct log *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 xlog_recover_t *trans,
1517 xfs_caddr_t dp,
1518 int len)
1519{
1520 xfs_inode_log_format_t *in_f; /* any will do */
1521 xlog_recover_item_t *item;
1522 xfs_caddr_t ptr;
1523
1524 if (!len)
1525 return 0;
Dave Chinnerf0a76952010-01-11 11:49:57 +00001526 if (list_empty(&trans->r_itemq)) {
David Chinner5a792c42008-10-30 17:40:09 +11001527 /* we need to catch log corruptions here */
1528 if (*(uint *)dp != XFS_TRANS_HEADER_MAGIC) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001529 xfs_warn(log->l_mp, "%s: bad header magic number",
1530 __func__);
David Chinner5a792c42008-10-30 17:40:09 +11001531 ASSERT(0);
1532 return XFS_ERROR(EIO);
1533 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 if (len == sizeof(xfs_trans_header_t))
1535 xlog_recover_add_item(&trans->r_itemq);
1536 memcpy(&trans->r_theader, dp, len); /* d, s, l */
1537 return 0;
1538 }
1539
1540 ptr = kmem_alloc(len, KM_SLEEP);
1541 memcpy(ptr, dp, len);
1542 in_f = (xfs_inode_log_format_t *)ptr;
1543
Dave Chinnerf0a76952010-01-11 11:49:57 +00001544 /* take the tail entry */
1545 item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
1546 if (item->ri_total != 0 &&
1547 item->ri_total == item->ri_cnt) {
1548 /* tail item is in use, get a new one */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 xlog_recover_add_item(&trans->r_itemq);
Dave Chinnerf0a76952010-01-11 11:49:57 +00001550 item = list_entry(trans->r_itemq.prev,
1551 xlog_recover_item_t, ri_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553
1554 if (item->ri_total == 0) { /* first region to be added */
Christoph Hellwige8fa6b42009-03-03 14:48:36 -05001555 if (in_f->ilf_size == 0 ||
1556 in_f->ilf_size > XLOG_MAX_REGIONS_IN_ITEM) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001557 xfs_warn(log->l_mp,
1558 "bad number of regions (%d) in inode log format",
Christoph Hellwige8fa6b42009-03-03 14:48:36 -05001559 in_f->ilf_size);
1560 ASSERT(0);
1561 return XFS_ERROR(EIO);
1562 }
1563
1564 item->ri_total = in_f->ilf_size;
1565 item->ri_buf =
1566 kmem_zalloc(item->ri_total * sizeof(xfs_log_iovec_t),
1567 KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 }
1569 ASSERT(item->ri_total > item->ri_cnt);
1570 /* Description region is ri_buf[0] */
1571 item->ri_buf[item->ri_cnt].i_addr = ptr;
1572 item->ri_buf[item->ri_cnt].i_len = len;
1573 item->ri_cnt++;
Dave Chinner9abbc532010-04-13 15:06:46 +10001574 trace_xfs_log_recover_item_add(log, trans, item, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 return 0;
1576}
1577
Dave Chinnerf0a76952010-01-11 11:49:57 +00001578/*
1579 * Sort the log items in the transaction. Cancelled buffers need
1580 * to be put first so they are processed before any items that might
1581 * modify the buffers. If they are cancelled, then the modifications
1582 * don't need to be replayed.
1583 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584STATIC int
1585xlog_recover_reorder_trans(
Dave Chinner9abbc532010-04-13 15:06:46 +10001586 struct log *log,
1587 xlog_recover_t *trans,
1588 int pass)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589{
Dave Chinnerf0a76952010-01-11 11:49:57 +00001590 xlog_recover_item_t *item, *n;
1591 LIST_HEAD(sort_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592
Dave Chinnerf0a76952010-01-11 11:49:57 +00001593 list_splice_init(&trans->r_itemq, &sort_list);
1594 list_for_each_entry_safe(item, n, &sort_list, ri_list) {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10001595 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
Dave Chinnerf0a76952010-01-11 11:49:57 +00001596
1597 switch (ITEM_TYPE(item)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 case XFS_LI_BUF:
Dave Chinnerc1155412010-05-07 11:05:19 +10001599 if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
Dave Chinner9abbc532010-04-13 15:06:46 +10001600 trace_xfs_log_recover_item_reorder_head(log,
1601 trans, item, pass);
Dave Chinnerf0a76952010-01-11 11:49:57 +00001602 list_move(&item->ri_list, &trans->r_itemq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 break;
1604 }
1605 case XFS_LI_INODE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 case XFS_LI_DQUOT:
1607 case XFS_LI_QUOTAOFF:
1608 case XFS_LI_EFD:
1609 case XFS_LI_EFI:
Dave Chinner9abbc532010-04-13 15:06:46 +10001610 trace_xfs_log_recover_item_reorder_tail(log,
1611 trans, item, pass);
Dave Chinnerf0a76952010-01-11 11:49:57 +00001612 list_move_tail(&item->ri_list, &trans->r_itemq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 break;
1614 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001615 xfs_warn(log->l_mp,
1616 "%s: unrecognized type of log operation",
1617 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 ASSERT(0);
1619 return XFS_ERROR(EIO);
1620 }
Dave Chinnerf0a76952010-01-11 11:49:57 +00001621 }
1622 ASSERT(list_empty(&sort_list));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 return 0;
1624}
1625
1626/*
1627 * Build up the table of buf cancel records so that we don't replay
1628 * cancelled data in the second pass. For buffer records that are
1629 * not cancel records, there is nothing to do here so we just return.
1630 *
1631 * If we get a cancel record which is already in the table, this indicates
1632 * that the buffer was cancelled multiple times. In order to ensure
1633 * that during pass 2 we keep the record in the table until we reach its
1634 * last occurrence in the log, we keep a reference count in the cancel
1635 * record in the table to tell us how many times we expect to see this
1636 * record during the second pass.
1637 */
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001638STATIC int
1639xlog_recover_buffer_pass1(
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001640 struct log *log,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001641 xlog_recover_item_t *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001643 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001644 struct list_head *bucket;
1645 struct xfs_buf_cancel *bcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
1647 /*
1648 * If this isn't a cancel buffer item, then just return.
1649 */
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001650 if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
Dave Chinner9abbc532010-04-13 15:06:46 +10001651 trace_xfs_log_recover_buf_not_cancel(log, buf_f);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001652 return 0;
Dave Chinner9abbc532010-04-13 15:06:46 +10001653 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654
1655 /*
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001656 * Insert an xfs_buf_cancel record into the hash table of them.
1657 * If there is already an identical record, bump its reference count.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 */
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001659 bucket = XLOG_BUF_CANCEL_BUCKET(log, buf_f->blf_blkno);
1660 list_for_each_entry(bcp, bucket, bc_list) {
1661 if (bcp->bc_blkno == buf_f->blf_blkno &&
1662 bcp->bc_len == buf_f->blf_len) {
1663 bcp->bc_refcount++;
Dave Chinner9abbc532010-04-13 15:06:46 +10001664 trace_xfs_log_recover_buf_cancel_ref_inc(log, buf_f);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001665 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 }
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001668
1669 bcp = kmem_alloc(sizeof(struct xfs_buf_cancel), KM_SLEEP);
1670 bcp->bc_blkno = buf_f->blf_blkno;
1671 bcp->bc_len = buf_f->blf_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 bcp->bc_refcount = 1;
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001673 list_add_tail(&bcp->bc_list, bucket);
1674
Dave Chinner9abbc532010-04-13 15:06:46 +10001675 trace_xfs_log_recover_buf_cancel_add(log, buf_f);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001676 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677}
1678
1679/*
1680 * Check to see whether the buffer being recovered has a corresponding
1681 * entry in the buffer cancel record table. If it does then return 1
1682 * so that it will be cancelled, otherwise return 0. If the buffer is
Dave Chinnerc1155412010-05-07 11:05:19 +10001683 * actually a buffer cancel item (XFS_BLF_CANCEL is set), then decrement
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 * the refcount on the entry in the table and remove it from the table
1685 * if this is the last reference.
1686 *
1687 * We remove the cancel record from the table when we encounter its
1688 * last occurrence in the log so that if the same buffer is re-used
1689 * again after its last cancellation we actually replay the changes
1690 * made at that point.
1691 */
1692STATIC int
1693xlog_check_buffer_cancelled(
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001694 struct log *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 xfs_daddr_t blkno,
1696 uint len,
1697 ushort flags)
1698{
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001699 struct list_head *bucket;
1700 struct xfs_buf_cancel *bcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701
1702 if (log->l_buf_cancel_table == NULL) {
1703 /*
1704 * There is nothing in the table built in pass one,
1705 * so this buffer must not be cancelled.
1706 */
Dave Chinnerc1155412010-05-07 11:05:19 +10001707 ASSERT(!(flags & XFS_BLF_CANCEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 return 0;
1709 }
1710
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001711 /*
1712 * Search for an entry in the cancel table that matches our buffer.
1713 */
1714 bucket = XLOG_BUF_CANCEL_BUCKET(log, blkno);
1715 list_for_each_entry(bcp, bucket, bc_list) {
1716 if (bcp->bc_blkno == blkno && bcp->bc_len == len)
1717 goto found;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 }
1719
1720 /*
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001721 * We didn't find a corresponding entry in the table, so return 0 so
1722 * that the buffer is NOT cancelled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 */
Dave Chinnerc1155412010-05-07 11:05:19 +10001724 ASSERT(!(flags & XFS_BLF_CANCEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 return 0;
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001726
1727found:
1728 /*
1729 * We've go a match, so return 1 so that the recovery of this buffer
1730 * is cancelled. If this buffer is actually a buffer cancel log
1731 * item, then decrement the refcount on the one in the table and
1732 * remove it if this is the last reference.
1733 */
1734 if (flags & XFS_BLF_CANCEL) {
1735 if (--bcp->bc_refcount == 0) {
1736 list_del(&bcp->bc_list);
1737 kmem_free(bcp);
1738 }
1739 }
1740 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741}
1742
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743/*
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001744 * Perform recovery for a buffer full of inodes. In these buffers, the only
1745 * data which should be recovered is that which corresponds to the
1746 * di_next_unlinked pointers in the on disk inode structures. The rest of the
1747 * data for the inodes is always logged through the inodes themselves rather
1748 * than the inode buffer and is recovered in xlog_recover_inode_pass2().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 *
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001750 * The only time when buffers full of inodes are fully recovered is when the
1751 * buffer is full of newly allocated inodes. In this case the buffer will
1752 * not be marked as an inode buffer and so will be sent to
1753 * xlog_recover_do_reg_buffer() below during recovery.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 */
1755STATIC int
1756xlog_recover_do_inode_buffer(
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001757 struct xfs_mount *mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 xlog_recover_item_t *item,
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001759 struct xfs_buf *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 xfs_buf_log_format_t *buf_f)
1761{
1762 int i;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001763 int item_index = 0;
1764 int bit = 0;
1765 int nbits = 0;
1766 int reg_buf_offset = 0;
1767 int reg_buf_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 int next_unlinked_offset;
1769 int inodes_per_buf;
1770 xfs_agino_t *logged_nextp;
1771 xfs_agino_t *buffer_nextp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772
Dave Chinner9abbc532010-04-13 15:06:46 +10001773 trace_xfs_log_recover_buf_inode_buf(mp->m_log, buf_f);
1774
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 inodes_per_buf = XFS_BUF_COUNT(bp) >> mp->m_sb.sb_inodelog;
1776 for (i = 0; i < inodes_per_buf; i++) {
1777 next_unlinked_offset = (i * mp->m_sb.sb_inodesize) +
1778 offsetof(xfs_dinode_t, di_next_unlinked);
1779
1780 while (next_unlinked_offset >=
1781 (reg_buf_offset + reg_buf_bytes)) {
1782 /*
1783 * The next di_next_unlinked field is beyond
1784 * the current logged region. Find the next
1785 * logged region that contains or is beyond
1786 * the current di_next_unlinked field.
1787 */
1788 bit += nbits;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001789 bit = xfs_next_bit(buf_f->blf_data_map,
1790 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791
1792 /*
1793 * If there are no more logged regions in the
1794 * buffer, then we're done.
1795 */
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001796 if (bit == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001799 nbits = xfs_contig_bits(buf_f->blf_data_map,
1800 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 ASSERT(nbits > 0);
Dave Chinnerc1155412010-05-07 11:05:19 +10001802 reg_buf_offset = bit << XFS_BLF_SHIFT;
1803 reg_buf_bytes = nbits << XFS_BLF_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 item_index++;
1805 }
1806
1807 /*
1808 * If the current logged region starts after the current
1809 * di_next_unlinked field, then move on to the next
1810 * di_next_unlinked field.
1811 */
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001812 if (next_unlinked_offset < reg_buf_offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814
1815 ASSERT(item->ri_buf[item_index].i_addr != NULL);
Dave Chinnerc1155412010-05-07 11:05:19 +10001816 ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 ASSERT((reg_buf_offset + reg_buf_bytes) <= XFS_BUF_COUNT(bp));
1818
1819 /*
1820 * The current logged region contains a copy of the
1821 * current di_next_unlinked field. Extract its value
1822 * and copy it to the buffer copy.
1823 */
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10001824 logged_nextp = item->ri_buf[item_index].i_addr +
1825 next_unlinked_offset - reg_buf_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 if (unlikely(*logged_nextp == 0)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001827 xfs_alert(mp,
1828 "Bad inode buffer log record (ptr = 0x%p, bp = 0x%p). "
1829 "Trying to replay bad (0) inode di_next_unlinked field.",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 item, bp);
1831 XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
1832 XFS_ERRLEVEL_LOW, mp);
1833 return XFS_ERROR(EFSCORRUPTED);
1834 }
1835
1836 buffer_nextp = (xfs_agino_t *)xfs_buf_offset(bp,
1837 next_unlinked_offset);
Tim Shimmin87c199c2006-06-09 14:56:16 +10001838 *buffer_nextp = *logged_nextp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 }
1840
1841 return 0;
1842}
1843
1844/*
1845 * Perform a 'normal' buffer recovery. Each logged region of the
1846 * buffer should be copied over the corresponding region in the
1847 * given buffer. The bitmap in the buf log format structure indicates
1848 * where to place the logged data.
1849 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850STATIC void
1851xlog_recover_do_reg_buffer(
Dave Chinner9abbc532010-04-13 15:06:46 +10001852 struct xfs_mount *mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 xlog_recover_item_t *item,
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001854 struct xfs_buf *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 xfs_buf_log_format_t *buf_f)
1856{
1857 int i;
1858 int bit;
1859 int nbits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 int error;
1861
Dave Chinner9abbc532010-04-13 15:06:46 +10001862 trace_xfs_log_recover_buf_reg_buf(mp->m_log, buf_f);
1863
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 bit = 0;
1865 i = 1; /* 0 is the buf format structure */
1866 while (1) {
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001867 bit = xfs_next_bit(buf_f->blf_data_map,
1868 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 if (bit == -1)
1870 break;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001871 nbits = xfs_contig_bits(buf_f->blf_data_map,
1872 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 ASSERT(nbits > 0);
Christoph Hellwig4b809162007-08-16 15:37:36 +10001874 ASSERT(item->ri_buf[i].i_addr != NULL);
Dave Chinnerc1155412010-05-07 11:05:19 +10001875 ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 ASSERT(XFS_BUF_COUNT(bp) >=
Dave Chinnerc1155412010-05-07 11:05:19 +10001877 ((uint)bit << XFS_BLF_SHIFT)+(nbits<<XFS_BLF_SHIFT));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878
1879 /*
1880 * Do a sanity check if this is a dquot buffer. Just checking
1881 * the first dquot in the buffer should do. XXXThis is
1882 * probably a good thing to do for other buf types also.
1883 */
1884 error = 0;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001885 if (buf_f->blf_flags &
Dave Chinnerc1155412010-05-07 11:05:19 +10001886 (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001887 if (item->ri_buf[i].i_addr == NULL) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001888 xfs_alert(mp,
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001889 "XFS: NULL dquot in %s.", __func__);
1890 goto next;
1891 }
Jan Rekorajski8ec6dba2009-11-16 11:57:02 +00001892 if (item->ri_buf[i].i_len < sizeof(xfs_disk_dquot_t)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001893 xfs_alert(mp,
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001894 "XFS: dquot too small (%d) in %s.",
1895 item->ri_buf[i].i_len, __func__);
1896 goto next;
1897 }
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001898 error = xfs_qm_dqcheck(mp, item->ri_buf[i].i_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 -1, 0, XFS_QMOPT_DOWARN,
1900 "dquot_buf_recover");
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001901 if (error)
1902 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 }
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001904
1905 memcpy(xfs_buf_offset(bp,
Dave Chinnerc1155412010-05-07 11:05:19 +10001906 (uint)bit << XFS_BLF_SHIFT), /* dest */
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001907 item->ri_buf[i].i_addr, /* source */
Dave Chinnerc1155412010-05-07 11:05:19 +10001908 nbits<<XFS_BLF_SHIFT); /* length */
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001909 next:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 i++;
1911 bit += nbits;
1912 }
1913
1914 /* Shouldn't be any more regions */
1915 ASSERT(i == item->ri_total);
1916}
1917
1918/*
1919 * Do some primitive error checking on ondisk dquot data structures.
1920 */
1921int
1922xfs_qm_dqcheck(
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001923 struct xfs_mount *mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 xfs_disk_dquot_t *ddq,
1925 xfs_dqid_t id,
1926 uint type, /* used only when IO_dorepair is true */
1927 uint flags,
1928 char *str)
1929{
1930 xfs_dqblk_t *d = (xfs_dqblk_t *)ddq;
1931 int errs = 0;
1932
1933 /*
1934 * We can encounter an uninitialized dquot buffer for 2 reasons:
1935 * 1. If we crash while deleting the quotainode(s), and those blks got
1936 * used for user data. This is because we take the path of regular
1937 * file deletion; however, the size field of quotainodes is never
1938 * updated, so all the tricks that we play in itruncate_finish
1939 * don't quite matter.
1940 *
1941 * 2. We don't play the quota buffers when there's a quotaoff logitem.
1942 * But the allocation will be replayed so we'll end up with an
1943 * uninitialized quota block.
1944 *
1945 * This is all fine; things are still consistent, and we haven't lost
1946 * any quota information. Just don't complain about bad dquot blks.
1947 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001948 if (ddq->d_magic != cpu_to_be16(XFS_DQUOT_MAGIC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001950 xfs_alert(mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 "%s : XFS dquot ID 0x%x, magic 0x%x != 0x%x",
Christoph Hellwig1149d962005-11-02 15:01:12 +11001952 str, id, be16_to_cpu(ddq->d_magic), XFS_DQUOT_MAGIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 errs++;
1954 }
Christoph Hellwig1149d962005-11-02 15:01:12 +11001955 if (ddq->d_version != XFS_DQUOT_VERSION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001957 xfs_alert(mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 "%s : XFS dquot ID 0x%x, version 0x%x != 0x%x",
Christoph Hellwig1149d962005-11-02 15:01:12 +11001959 str, id, ddq->d_version, XFS_DQUOT_VERSION);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 errs++;
1961 }
1962
Christoph Hellwig1149d962005-11-02 15:01:12 +11001963 if (ddq->d_flags != XFS_DQ_USER &&
1964 ddq->d_flags != XFS_DQ_PROJ &&
1965 ddq->d_flags != XFS_DQ_GROUP) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001967 xfs_alert(mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 "%s : XFS dquot ID 0x%x, unknown flags 0x%x",
Christoph Hellwig1149d962005-11-02 15:01:12 +11001969 str, id, ddq->d_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 errs++;
1971 }
1972
Christoph Hellwig1149d962005-11-02 15:01:12 +11001973 if (id != -1 && id != be32_to_cpu(ddq->d_id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001975 xfs_alert(mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 "%s : ondisk-dquot 0x%p, ID mismatch: "
1977 "0x%x expected, found id 0x%x",
Christoph Hellwig1149d962005-11-02 15:01:12 +11001978 str, ddq, id, be32_to_cpu(ddq->d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 errs++;
1980 }
1981
1982 if (!errs && ddq->d_id) {
Christoph Hellwig1149d962005-11-02 15:01:12 +11001983 if (ddq->d_blk_softlimit &&
1984 be64_to_cpu(ddq->d_bcount) >=
1985 be64_to_cpu(ddq->d_blk_softlimit)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 if (!ddq->d_btimer) {
1987 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001988 xfs_alert(mp,
1989 "%s : Dquot ID 0x%x (0x%p) BLK TIMER NOT STARTED",
Christoph Hellwig1149d962005-11-02 15:01:12 +11001990 str, (int)be32_to_cpu(ddq->d_id), ddq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 errs++;
1992 }
1993 }
Christoph Hellwig1149d962005-11-02 15:01:12 +11001994 if (ddq->d_ino_softlimit &&
1995 be64_to_cpu(ddq->d_icount) >=
1996 be64_to_cpu(ddq->d_ino_softlimit)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 if (!ddq->d_itimer) {
1998 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001999 xfs_alert(mp,
2000 "%s : Dquot ID 0x%x (0x%p) INODE TIMER NOT STARTED",
Christoph Hellwig1149d962005-11-02 15:01:12 +11002001 str, (int)be32_to_cpu(ddq->d_id), ddq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 errs++;
2003 }
2004 }
Christoph Hellwig1149d962005-11-02 15:01:12 +11002005 if (ddq->d_rtb_softlimit &&
2006 be64_to_cpu(ddq->d_rtbcount) >=
2007 be64_to_cpu(ddq->d_rtb_softlimit)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 if (!ddq->d_rtbtimer) {
2009 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002010 xfs_alert(mp,
2011 "%s : Dquot ID 0x%x (0x%p) RTBLK TIMER NOT STARTED",
Christoph Hellwig1149d962005-11-02 15:01:12 +11002012 str, (int)be32_to_cpu(ddq->d_id), ddq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 errs++;
2014 }
2015 }
2016 }
2017
2018 if (!errs || !(flags & XFS_QMOPT_DQREPAIR))
2019 return errs;
2020
2021 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002022 xfs_notice(mp, "Re-initializing dquot ID 0x%x", id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023
2024 /*
2025 * Typically, a repair is only requested by quotacheck.
2026 */
2027 ASSERT(id != -1);
2028 ASSERT(flags & XFS_QMOPT_DQREPAIR);
2029 memset(d, 0, sizeof(xfs_dqblk_t));
Christoph Hellwig1149d962005-11-02 15:01:12 +11002030
2031 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
2032 d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
2033 d->dd_diskdq.d_flags = type;
2034 d->dd_diskdq.d_id = cpu_to_be32(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035
2036 return errs;
2037}
2038
2039/*
2040 * Perform a dquot buffer recovery.
2041 * Simple algorithm: if we have found a QUOTAOFF logitem of the same type
2042 * (ie. USR or GRP), then just toss this buffer away; don't recover it.
2043 * Else, treat it as a regular buffer and do recovery.
2044 */
2045STATIC void
2046xlog_recover_do_dquot_buffer(
2047 xfs_mount_t *mp,
2048 xlog_t *log,
2049 xlog_recover_item_t *item,
2050 xfs_buf_t *bp,
2051 xfs_buf_log_format_t *buf_f)
2052{
2053 uint type;
2054
Dave Chinner9abbc532010-04-13 15:06:46 +10002055 trace_xfs_log_recover_buf_dquot_buf(log, buf_f);
2056
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 /*
2058 * Filesystems are required to send in quota flags at mount time.
2059 */
2060 if (mp->m_qflags == 0) {
2061 return;
2062 }
2063
2064 type = 0;
Dave Chinnerc1155412010-05-07 11:05:19 +10002065 if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 type |= XFS_DQ_USER;
Dave Chinnerc1155412010-05-07 11:05:19 +10002067 if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002068 type |= XFS_DQ_PROJ;
Dave Chinnerc1155412010-05-07 11:05:19 +10002069 if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 type |= XFS_DQ_GROUP;
2071 /*
2072 * This type of quotas was turned off, so ignore this buffer
2073 */
2074 if (log->l_quotaoffs_flag & type)
2075 return;
2076
Dave Chinner9abbc532010-04-13 15:06:46 +10002077 xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078}
2079
2080/*
2081 * This routine replays a modification made to a buffer at runtime.
2082 * There are actually two types of buffer, regular and inode, which
2083 * are handled differently. Inode buffers are handled differently
2084 * in that we only recover a specific set of data from them, namely
2085 * the inode di_next_unlinked fields. This is because all other inode
2086 * data is actually logged via inode records and any data we replay
2087 * here which overlaps that may be stale.
2088 *
2089 * When meta-data buffers are freed at run time we log a buffer item
Dave Chinnerc1155412010-05-07 11:05:19 +10002090 * with the XFS_BLF_CANCEL bit set to indicate that previous copies
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 * of the buffer in the log should not be replayed at recovery time.
2092 * This is so that if the blocks covered by the buffer are reused for
2093 * file data before we crash we don't end up replaying old, freed
2094 * meta-data into a user's file.
2095 *
2096 * To handle the cancellation of buffer log items, we make two passes
2097 * over the log during recovery. During the first we build a table of
2098 * those buffers which have been cancelled, and during the second we
2099 * only replay those buffers which do not have corresponding cancel
2100 * records in the table. See xlog_recover_do_buffer_pass[1,2] above
2101 * for more details on the implementation of the table of cancel records.
2102 */
2103STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002104xlog_recover_buffer_pass2(
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 xlog_t *log,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002106 xlog_recover_item_t *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107{
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002108 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002109 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 xfs_buf_t *bp;
2111 int error;
Christoph Hellwig6ad112b2009-11-24 18:02:23 +00002112 uint buf_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002114 /*
2115 * In this pass we only want to recover all the buffers which have
2116 * not been cancelled and are not cancellation buffers themselves.
2117 */
2118 if (xlog_check_buffer_cancelled(log, buf_f->blf_blkno,
2119 buf_f->blf_len, buf_f->blf_flags)) {
2120 trace_xfs_log_recover_buf_cancel(log, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 }
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002123
Dave Chinner9abbc532010-04-13 15:06:46 +10002124 trace_xfs_log_recover_buf_recover(log, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125
Christoph Hellwig0cadda12010-01-19 09:56:44 +00002126 buf_flags = XBF_LOCK;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002127 if (!(buf_f->blf_flags & XFS_BLF_INODE_BUF))
Christoph Hellwig0cadda12010-01-19 09:56:44 +00002128 buf_flags |= XBF_MAPPED;
Christoph Hellwig6ad112b2009-11-24 18:02:23 +00002129
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002130 bp = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len,
2131 buf_flags);
Chandra Seetharamanac4d6882011-08-03 02:18:29 +00002132 if (!bp)
2133 return XFS_ERROR(ENOMEM);
Chandra Seetharamane5702802011-08-03 02:18:34 +00002134 error = bp->b_error;
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +00002135 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +00002136 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 xfs_buf_relse(bp);
2138 return error;
2139 }
2140
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002141 if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002143 } else if (buf_f->blf_flags &
Dave Chinnerc1155412010-05-07 11:05:19 +10002144 (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
2146 } else {
Dave Chinner9abbc532010-04-13 15:06:46 +10002147 xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 }
2149 if (error)
2150 return XFS_ERROR(error);
2151
2152 /*
2153 * Perform delayed write on the buffer. Asynchronous writes will be
2154 * slower when taking into account all the buffers to be flushed.
2155 *
2156 * Also make sure that only inode buffers with good sizes stay in
2157 * the buffer cache. The kernel moves inodes in buffers of 1 block
2158 * or XFS_INODE_CLUSTER_SIZE bytes, whichever is bigger. The inode
2159 * buffers in the log can be a different size if the log was generated
2160 * by an older kernel using unclustered inode buffers or a newer kernel
2161 * running with a different inode cluster size. Regardless, if the
2162 * the inode buffer size isn't MAX(blocksize, XFS_INODE_CLUSTER_SIZE)
2163 * for *our* value of XFS_INODE_CLUSTER_SIZE, then we need to keep
2164 * the buffer out of the buffer cache so that the buffer won't
2165 * overlap with future reads of those inodes.
2166 */
2167 if (XFS_DINODE_MAGIC ==
Christoph Hellwigb53e6752007-10-12 10:59:34 +10002168 be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 (XFS_BUF_COUNT(bp) != MAX(log->l_mp->m_sb.sb_blocksize,
2170 (__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {
Christoph Hellwigc867cb62011-10-10 16:52:46 +00002171 xfs_buf_stale(bp);
Christoph Hellwigc2b006c2011-08-23 08:28:07 +00002172 error = xfs_bwrite(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 } else {
Dave Chinnerebad8612010-09-22 10:47:20 +10002174 ASSERT(bp->b_target->bt_mount == mp);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02002175 bp->b_iodone = xlog_recover_iodone;
Christoph Hellwig61551f12011-08-23 08:28:06 +00002176 xfs_buf_delwri_queue(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 }
2178
Christoph Hellwigc2b006c2011-08-23 08:28:07 +00002179 xfs_buf_relse(bp);
2180 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181}
2182
2183STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002184xlog_recover_inode_pass2(
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 xlog_t *log,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002186 xlog_recover_item_t *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187{
2188 xfs_inode_log_format_t *in_f;
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002189 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 xfs_buf_t *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 xfs_dinode_t *dip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 int len;
2193 xfs_caddr_t src;
2194 xfs_caddr_t dest;
2195 int error;
2196 int attr_index;
2197 uint fields;
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002198 xfs_icdinode_t *dicp;
Tim Shimmin6d192a92006-06-09 14:55:38 +10002199 int need_free = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200
Tim Shimmin6d192a92006-06-09 14:55:38 +10002201 if (item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t)) {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002202 in_f = item->ri_buf[0].i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +10002203 } else {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002204 in_f = kmem_alloc(sizeof(xfs_inode_log_format_t), KM_SLEEP);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002205 need_free = 1;
2206 error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
2207 if (error)
2208 goto error;
2209 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210
2211 /*
2212 * Inode buffers can be freed, look out for it,
2213 * and do not replay the inode.
2214 */
Christoph Hellwiga1941892008-11-28 14:23:40 +11002215 if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno,
2216 in_f->ilf_len, 0)) {
Tim Shimmin6d192a92006-06-09 14:55:38 +10002217 error = 0;
Dave Chinner9abbc532010-04-13 15:06:46 +10002218 trace_xfs_log_recover_inode_cancel(log, in_f);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002219 goto error;
2220 }
Dave Chinner9abbc532010-04-13 15:06:46 +10002221 trace_xfs_log_recover_inode_recover(log, in_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222
Christoph Hellwig6ad112b2009-11-24 18:02:23 +00002223 bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len,
Christoph Hellwig0cadda12010-01-19 09:56:44 +00002224 XBF_LOCK);
Chandra Seetharamanac4d6882011-08-03 02:18:29 +00002225 if (!bp) {
2226 error = ENOMEM;
2227 goto error;
2228 }
Chandra Seetharamane5702802011-08-03 02:18:34 +00002229 error = bp->b_error;
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +00002230 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +00002231 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#2)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 xfs_buf_relse(bp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002233 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
Christoph Hellwiga1941892008-11-28 14:23:40 +11002236 dip = (xfs_dinode_t *)xfs_buf_offset(bp, in_f->ilf_boffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237
2238 /*
2239 * Make sure the place we're flushing out to really looks
2240 * like an inode!
2241 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002242 if (unlikely(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002244 xfs_alert(mp,
2245 "%s: Bad inode magic number, dip = 0x%p, dino bp = 0x%p, ino = %Ld",
2246 __func__, dip, bp, in_f->ilf_ino);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002247 XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 XFS_ERRLEVEL_LOW, mp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002249 error = EFSCORRUPTED;
2250 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 }
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002252 dicp = item->ri_buf[1].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) {
2254 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002255 xfs_alert(mp,
2256 "%s: Bad inode log record, rec ptr 0x%p, ino %Ld",
2257 __func__, item, in_f->ilf_ino);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002258 XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 XFS_ERRLEVEL_LOW, mp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002260 error = EFSCORRUPTED;
2261 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 }
2263
2264 /* Skip replay when the on disk inode is newer than the log one */
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002265 if (dicp->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 /*
2267 * Deal with the wrap case, DI_MAX_FLUSH is less
2268 * than smaller numbers
2269 */
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002270 if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002271 dicp->di_flushiter < (DI_MAX_FLUSH >> 1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 /* do nothing */
2273 } else {
2274 xfs_buf_relse(bp);
Dave Chinner9abbc532010-04-13 15:06:46 +10002275 trace_xfs_log_recover_inode_skip(log, in_f);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002276 error = 0;
2277 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278 }
2279 }
2280 /* Take the opportunity to reset the flush iteration count */
2281 dicp->di_flushiter = 0;
2282
Al Viroabbede12011-07-26 02:31:30 -04002283 if (unlikely(S_ISREG(dicp->di_mode))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2285 (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002286 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 XFS_ERRLEVEL_LOW, mp, dicp);
2288 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002289 xfs_alert(mp,
2290 "%s: Bad regular inode log record, rec ptr 0x%p, "
2291 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2292 __func__, item, dip, bp, in_f->ilf_ino);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002293 error = EFSCORRUPTED;
2294 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 }
Al Viroabbede12011-07-26 02:31:30 -04002296 } else if (unlikely(S_ISDIR(dicp->di_mode))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2298 (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
2299 (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002300 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(4)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 XFS_ERRLEVEL_LOW, mp, dicp);
2302 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002303 xfs_alert(mp,
2304 "%s: Bad dir inode log record, rec ptr 0x%p, "
2305 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2306 __func__, item, dip, bp, in_f->ilf_ino);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002307 error = EFSCORRUPTED;
2308 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 }
2310 }
2311 if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002312 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 XFS_ERRLEVEL_LOW, mp, dicp);
2314 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002315 xfs_alert(mp,
2316 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
2317 "dino bp 0x%p, ino %Ld, total extents = %d, nblocks = %Ld",
2318 __func__, item, dip, bp, in_f->ilf_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 dicp->di_nextents + dicp->di_anextents,
2320 dicp->di_nblocks);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002321 error = EFSCORRUPTED;
2322 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323 }
2324 if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002325 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 XFS_ERRLEVEL_LOW, mp, dicp);
2327 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002328 xfs_alert(mp,
2329 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
2330 "dino bp 0x%p, ino %Ld, forkoff 0x%x", __func__,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002331 item, dip, bp, in_f->ilf_ino, dicp->di_forkoff);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002332 error = EFSCORRUPTED;
2333 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 }
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002335 if (unlikely(item->ri_buf[1].i_len > sizeof(struct xfs_icdinode))) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002336 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 XFS_ERRLEVEL_LOW, mp, dicp);
2338 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002339 xfs_alert(mp,
2340 "%s: Bad inode log record length %d, rec ptr 0x%p",
2341 __func__, item->ri_buf[1].i_len, item);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002342 error = EFSCORRUPTED;
2343 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 }
2345
2346 /* The core is in in-core format */
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002347 xfs_dinode_to_disk(dip, item->ri_buf[1].i_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348
2349 /* the rest is in on-disk format */
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002350 if (item->ri_buf[1].i_len > sizeof(struct xfs_icdinode)) {
2351 memcpy((xfs_caddr_t) dip + sizeof(struct xfs_icdinode),
2352 item->ri_buf[1].i_addr + sizeof(struct xfs_icdinode),
2353 item->ri_buf[1].i_len - sizeof(struct xfs_icdinode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 }
2355
2356 fields = in_f->ilf_fields;
2357 switch (fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) {
2358 case XFS_ILOG_DEV:
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002359 xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360 break;
2361 case XFS_ILOG_UUID:
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002362 memcpy(XFS_DFORK_DPTR(dip),
2363 &in_f->ilf_u.ilfu_uuid,
2364 sizeof(uuid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365 break;
2366 }
2367
2368 if (in_f->ilf_size == 2)
2369 goto write_inode_buffer;
2370 len = item->ri_buf[2].i_len;
2371 src = item->ri_buf[2].i_addr;
2372 ASSERT(in_f->ilf_size <= 4);
2373 ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK));
2374 ASSERT(!(fields & XFS_ILOG_DFORK) ||
2375 (len == in_f->ilf_dsize));
2376
2377 switch (fields & XFS_ILOG_DFORK) {
2378 case XFS_ILOG_DDATA:
2379 case XFS_ILOG_DEXT:
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002380 memcpy(XFS_DFORK_DPTR(dip), src, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 break;
2382
2383 case XFS_ILOG_DBROOT:
Christoph Hellwig7cc95a82008-10-30 17:14:34 +11002384 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, len,
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002385 (xfs_bmdr_block_t *)XFS_DFORK_DPTR(dip),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386 XFS_DFORK_DSIZE(dip, mp));
2387 break;
2388
2389 default:
2390 /*
2391 * There are no data fork flags set.
2392 */
2393 ASSERT((fields & XFS_ILOG_DFORK) == 0);
2394 break;
2395 }
2396
2397 /*
2398 * If we logged any attribute data, recover it. There may or
2399 * may not have been any other non-core data logged in this
2400 * transaction.
2401 */
2402 if (in_f->ilf_fields & XFS_ILOG_AFORK) {
2403 if (in_f->ilf_fields & XFS_ILOG_DFORK) {
2404 attr_index = 3;
2405 } else {
2406 attr_index = 2;
2407 }
2408 len = item->ri_buf[attr_index].i_len;
2409 src = item->ri_buf[attr_index].i_addr;
2410 ASSERT(len == in_f->ilf_asize);
2411
2412 switch (in_f->ilf_fields & XFS_ILOG_AFORK) {
2413 case XFS_ILOG_ADATA:
2414 case XFS_ILOG_AEXT:
2415 dest = XFS_DFORK_APTR(dip);
2416 ASSERT(len <= XFS_DFORK_ASIZE(dip, mp));
2417 memcpy(dest, src, len);
2418 break;
2419
2420 case XFS_ILOG_ABROOT:
2421 dest = XFS_DFORK_APTR(dip);
Christoph Hellwig7cc95a82008-10-30 17:14:34 +11002422 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src,
2423 len, (xfs_bmdr_block_t*)dest,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424 XFS_DFORK_ASIZE(dip, mp));
2425 break;
2426
2427 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002428 xfs_warn(log->l_mp, "%s: Invalid flag", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 ASSERT(0);
2430 xfs_buf_relse(bp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002431 error = EIO;
2432 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 }
2434 }
2435
2436write_inode_buffer:
Dave Chinnerebad8612010-09-22 10:47:20 +10002437 ASSERT(bp->b_target->bt_mount == mp);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02002438 bp->b_iodone = xlog_recover_iodone;
Christoph Hellwig61551f12011-08-23 08:28:06 +00002439 xfs_buf_delwri_queue(bp);
2440 xfs_buf_relse(bp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002441error:
2442 if (need_free)
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002443 kmem_free(in_f);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002444 return XFS_ERROR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445}
2446
2447/*
2448 * Recover QUOTAOFF records. We simply make a note of it in the xlog_t
2449 * structure, so that we know not to do any dquot item or dquot buffer recovery,
2450 * of that type.
2451 */
2452STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002453xlog_recover_quotaoff_pass1(
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 xlog_t *log,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002455 xlog_recover_item_t *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002457 xfs_qoff_logformat_t *qoff_f = item->ri_buf[0].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 ASSERT(qoff_f);
2459
2460 /*
2461 * The logitem format's flag tells us if this was user quotaoff,
Nathan Scott77a7cce2006-01-11 15:35:57 +11002462 * group/project quotaoff or both.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463 */
2464 if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
2465 log->l_quotaoffs_flag |= XFS_DQ_USER;
Nathan Scott77a7cce2006-01-11 15:35:57 +11002466 if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
2467 log->l_quotaoffs_flag |= XFS_DQ_PROJ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468 if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
2469 log->l_quotaoffs_flag |= XFS_DQ_GROUP;
2470
2471 return (0);
2472}
2473
2474/*
2475 * Recover a dquot record
2476 */
2477STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002478xlog_recover_dquot_pass2(
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 xlog_t *log,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002480 xlog_recover_item_t *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002482 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 xfs_buf_t *bp;
2484 struct xfs_disk_dquot *ddq, *recddq;
2485 int error;
2486 xfs_dq_logformat_t *dq_f;
2487 uint type;
2488
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489
2490 /*
2491 * Filesystems are required to send in quota flags at mount time.
2492 */
2493 if (mp->m_qflags == 0)
2494 return (0);
2495
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002496 recddq = item->ri_buf[1].i_addr;
2497 if (recddq == NULL) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002498 xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002499 return XFS_ERROR(EIO);
2500 }
Jan Rekorajski8ec6dba2009-11-16 11:57:02 +00002501 if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002502 xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002503 item->ri_buf[1].i_len, __func__);
2504 return XFS_ERROR(EIO);
2505 }
2506
Linus Torvalds1da177e2005-04-16 15:20:36 -07002507 /*
2508 * This type of quotas was turned off, so ignore this record.
2509 */
Christoph Hellwigb53e6752007-10-12 10:59:34 +10002510 type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511 ASSERT(type);
2512 if (log->l_quotaoffs_flag & type)
2513 return (0);
2514
2515 /*
2516 * At this point we know that quota was _not_ turned off.
2517 * Since the mount flags are not indicating to us otherwise, this
2518 * must mean that quota is on, and the dquot needs to be replayed.
2519 * Remember that we may not have fully recovered the superblock yet,
2520 * so we can't do the usual trick of looking at the SB quota bits.
2521 *
2522 * The other possibility, of course, is that the quota subsystem was
2523 * removed since the last mount - ENOSYS.
2524 */
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002525 dq_f = item->ri_buf[0].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526 ASSERT(dq_f);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002527 error = xfs_qm_dqcheck(mp, recddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
2528 "xlog_recover_dquot_pass2 (log copy)");
2529 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530 return XFS_ERROR(EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531 ASSERT(dq_f->qlf_len == 1);
2532
2533 error = xfs_read_buf(mp, mp->m_ddev_targp,
2534 dq_f->qlf_blkno,
2535 XFS_FSB_TO_BB(mp, dq_f->qlf_len),
2536 0, &bp);
2537 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +00002538 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#3)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539 return error;
2540 }
2541 ASSERT(bp);
2542 ddq = (xfs_disk_dquot_t *)xfs_buf_offset(bp, dq_f->qlf_boffset);
2543
2544 /*
2545 * At least the magic num portion should be on disk because this
2546 * was among a chunk of dquots created earlier, and we did some
2547 * minimal initialization then.
2548 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002549 error = xfs_qm_dqcheck(mp, ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
2550 "xlog_recover_dquot_pass2");
2551 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552 xfs_buf_relse(bp);
2553 return XFS_ERROR(EIO);
2554 }
2555
2556 memcpy(ddq, recddq, item->ri_buf[1].i_len);
2557
2558 ASSERT(dq_f->qlf_size == 2);
Dave Chinnerebad8612010-09-22 10:47:20 +10002559 ASSERT(bp->b_target->bt_mount == mp);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02002560 bp->b_iodone = xlog_recover_iodone;
Christoph Hellwig61551f12011-08-23 08:28:06 +00002561 xfs_buf_delwri_queue(bp);
2562 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563
2564 return (0);
2565}
2566
2567/*
2568 * This routine is called to create an in-core extent free intent
2569 * item from the efi format structure which was logged on disk.
2570 * It allocates an in-core efi, copies the extents from the format
2571 * structure into it, and adds the efi to the AIL with the given
2572 * LSN.
2573 */
Tim Shimmin6d192a92006-06-09 14:55:38 +10002574STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002575xlog_recover_efi_pass2(
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576 xlog_t *log,
2577 xlog_recover_item_t *item,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002578 xfs_lsn_t lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579{
Tim Shimmin6d192a92006-06-09 14:55:38 +10002580 int error;
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002581 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 xfs_efi_log_item_t *efip;
2583 xfs_efi_log_format_t *efi_formatp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002585 efi_formatp = item->ri_buf[0].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587 efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002588 if ((error = xfs_efi_copy_format(&(item->ri_buf[0]),
2589 &(efip->efi_format)))) {
2590 xfs_efi_item_free(efip);
2591 return error;
2592 }
Dave Chinnerb199c8a2010-12-20 11:59:49 +11002593 atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594
David Chinnera9c21c12008-10-30 17:39:35 +11002595 spin_lock(&log->l_ailp->xa_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 /*
David Chinner783a2f62008-10-30 17:39:58 +11002597 * xfs_trans_ail_update() drops the AIL lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 */
Dave Chinnere6059942010-12-20 12:34:26 +11002599 xfs_trans_ail_update(log->l_ailp, &efip->efi_item, lsn);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002600 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601}
2602
2603
2604/*
2605 * This routine is called when an efd format structure is found in
2606 * a committed transaction in the log. It's purpose is to cancel
2607 * the corresponding efi if it was still in the log. To do this
2608 * it searches the AIL for the efi with an id equal to that in the
2609 * efd format structure. If we find it, we remove the efi from the
2610 * AIL and free it.
2611 */
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002612STATIC int
2613xlog_recover_efd_pass2(
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614 xlog_t *log,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002615 xlog_recover_item_t *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 xfs_efd_log_format_t *efd_formatp;
2618 xfs_efi_log_item_t *efip = NULL;
2619 xfs_log_item_t *lip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 __uint64_t efi_id;
David Chinner27d8d5f2008-10-30 17:38:39 +11002621 struct xfs_ail_cursor cur;
David Chinner783a2f62008-10-30 17:39:58 +11002622 struct xfs_ail *ailp = log->l_ailp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002624 efd_formatp = item->ri_buf[0].i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +10002625 ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) +
2626 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) ||
2627 (item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) +
2628 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t)))));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629 efi_id = efd_formatp->efd_efi_id;
2630
2631 /*
2632 * Search for the efi with the id in the efd format structure
2633 * in the AIL.
2634 */
David Chinnera9c21c12008-10-30 17:39:35 +11002635 spin_lock(&ailp->xa_lock);
2636 lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637 while (lip != NULL) {
2638 if (lip->li_type == XFS_LI_EFI) {
2639 efip = (xfs_efi_log_item_t *)lip;
2640 if (efip->efi_format.efi_id == efi_id) {
2641 /*
David Chinner783a2f62008-10-30 17:39:58 +11002642 * xfs_trans_ail_delete() drops the
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643 * AIL lock.
2644 */
David Chinner783a2f62008-10-30 17:39:58 +11002645 xfs_trans_ail_delete(ailp, lip);
David Chinner8ae2c0f2007-11-23 16:28:17 +11002646 xfs_efi_item_free(efip);
David Chinnera9c21c12008-10-30 17:39:35 +11002647 spin_lock(&ailp->xa_lock);
David Chinner27d8d5f2008-10-30 17:38:39 +11002648 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649 }
2650 }
David Chinnera9c21c12008-10-30 17:39:35 +11002651 lip = xfs_trans_ail_cursor_next(ailp, &cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 }
David Chinnera9c21c12008-10-30 17:39:35 +11002653 xfs_trans_ail_cursor_done(ailp, &cur);
2654 spin_unlock(&ailp->xa_lock);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002655
2656 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657}
2658
2659/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660 * Free up any resources allocated by the transaction
2661 *
2662 * Remember that EFIs, EFDs, and IUNLINKs are handled later.
2663 */
2664STATIC void
2665xlog_recover_free_trans(
Christoph Hellwigd0450942010-12-01 22:06:23 +00002666 struct xlog_recover *trans)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667{
Dave Chinnerf0a76952010-01-11 11:49:57 +00002668 xlog_recover_item_t *item, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669 int i;
2670
Dave Chinnerf0a76952010-01-11 11:49:57 +00002671 list_for_each_entry_safe(item, n, &trans->r_itemq, ri_list) {
2672 /* Free the regions in the item. */
2673 list_del(&item->ri_list);
2674 for (i = 0; i < item->ri_cnt; i++)
2675 kmem_free(item->ri_buf[i].i_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002676 /* Free the item itself */
Dave Chinnerf0a76952010-01-11 11:49:57 +00002677 kmem_free(item->ri_buf);
2678 kmem_free(item);
2679 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680 /* Free the transaction recover structure */
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002681 kmem_free(trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682}
2683
2684STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002685xlog_recover_commit_pass1(
Christoph Hellwigd0450942010-12-01 22:06:23 +00002686 struct log *log,
2687 struct xlog_recover *trans,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002688 xlog_recover_item_t *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002690 trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS1);
Christoph Hellwigd0450942010-12-01 22:06:23 +00002691
2692 switch (ITEM_TYPE(item)) {
2693 case XFS_LI_BUF:
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002694 return xlog_recover_buffer_pass1(log, item);
Christoph Hellwigd0450942010-12-01 22:06:23 +00002695 case XFS_LI_QUOTAOFF:
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002696 return xlog_recover_quotaoff_pass1(log, item);
2697 case XFS_LI_INODE:
2698 case XFS_LI_EFI:
2699 case XFS_LI_EFD:
2700 case XFS_LI_DQUOT:
2701 /* nothing to do in pass 1 */
2702 return 0;
Christoph Hellwigd0450942010-12-01 22:06:23 +00002703 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002704 xfs_warn(log->l_mp, "%s: invalid item type (%d)",
2705 __func__, ITEM_TYPE(item));
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002706 ASSERT(0);
2707 return XFS_ERROR(EIO);
2708 }
2709}
2710
2711STATIC int
2712xlog_recover_commit_pass2(
2713 struct log *log,
2714 struct xlog_recover *trans,
2715 xlog_recover_item_t *item)
2716{
2717 trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS2);
2718
2719 switch (ITEM_TYPE(item)) {
2720 case XFS_LI_BUF:
2721 return xlog_recover_buffer_pass2(log, item);
2722 case XFS_LI_INODE:
2723 return xlog_recover_inode_pass2(log, item);
2724 case XFS_LI_EFI:
2725 return xlog_recover_efi_pass2(log, item, trans->r_lsn);
2726 case XFS_LI_EFD:
2727 return xlog_recover_efd_pass2(log, item);
2728 case XFS_LI_DQUOT:
2729 return xlog_recover_dquot_pass2(log, item);
2730 case XFS_LI_QUOTAOFF:
2731 /* nothing to do in pass2 */
2732 return 0;
2733 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002734 xfs_warn(log->l_mp, "%s: invalid item type (%d)",
2735 __func__, ITEM_TYPE(item));
Christoph Hellwigd0450942010-12-01 22:06:23 +00002736 ASSERT(0);
2737 return XFS_ERROR(EIO);
2738 }
2739}
2740
2741/*
2742 * Perform the transaction.
2743 *
2744 * If the transaction modifies a buffer or inode, do it now. Otherwise,
2745 * EFIs and EFDs get queued up by adding entries into the AIL for them.
2746 */
2747STATIC int
2748xlog_recover_commit_trans(
2749 struct log *log,
2750 struct xlog_recover *trans,
2751 int pass)
2752{
2753 int error = 0;
2754 xlog_recover_item_t *item;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755
Dave Chinnerf0a76952010-01-11 11:49:57 +00002756 hlist_del(&trans->r_list);
Christoph Hellwigd0450942010-12-01 22:06:23 +00002757
2758 error = xlog_recover_reorder_trans(log, trans, pass);
2759 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760 return error;
Christoph Hellwigd0450942010-12-01 22:06:23 +00002761
2762 list_for_each_entry(item, &trans->r_itemq, ri_list) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002763 if (pass == XLOG_RECOVER_PASS1)
2764 error = xlog_recover_commit_pass1(log, trans, item);
2765 else
2766 error = xlog_recover_commit_pass2(log, trans, item);
Christoph Hellwigd0450942010-12-01 22:06:23 +00002767 if (error)
2768 return error;
2769 }
2770
2771 xlog_recover_free_trans(trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772 return 0;
2773}
2774
2775STATIC int
2776xlog_recover_unmount_trans(
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002777 struct log *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 xlog_recover_t *trans)
2779{
2780 /* Do nothing now */
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002781 xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 return 0;
2783}
2784
2785/*
2786 * There are two valid states of the r_state field. 0 indicates that the
2787 * transaction structure is in a normal state. We have either seen the
2788 * start of the transaction or the last operation we added was not a partial
2789 * operation. If the last operation we added to the transaction was a
2790 * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
2791 *
2792 * NOTE: skip LRs with 0 data length.
2793 */
2794STATIC int
2795xlog_recover_process_data(
2796 xlog_t *log,
Dave Chinnerf0a76952010-01-11 11:49:57 +00002797 struct hlist_head rhash[],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798 xlog_rec_header_t *rhead,
2799 xfs_caddr_t dp,
2800 int pass)
2801{
2802 xfs_caddr_t lp;
2803 int num_logops;
2804 xlog_op_header_t *ohead;
2805 xlog_recover_t *trans;
2806 xlog_tid_t tid;
2807 int error;
2808 unsigned long hash;
2809 uint flags;
2810
Christoph Hellwigb53e6752007-10-12 10:59:34 +10002811 lp = dp + be32_to_cpu(rhead->h_len);
2812 num_logops = be32_to_cpu(rhead->h_num_logops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813
2814 /* check the log format matches our own - else we can't recover */
2815 if (xlog_header_check_recover(log->l_mp, rhead))
2816 return (XFS_ERROR(EIO));
2817
2818 while ((dp < lp) && num_logops) {
2819 ASSERT(dp + sizeof(xlog_op_header_t) <= lp);
2820 ohead = (xlog_op_header_t *)dp;
2821 dp += sizeof(xlog_op_header_t);
2822 if (ohead->oh_clientid != XFS_TRANSACTION &&
2823 ohead->oh_clientid != XFS_LOG) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002824 xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
2825 __func__, ohead->oh_clientid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826 ASSERT(0);
2827 return (XFS_ERROR(EIO));
2828 }
Christoph Hellwig67fcb7b2007-10-12 10:58:59 +10002829 tid = be32_to_cpu(ohead->oh_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830 hash = XLOG_RHASH(tid);
Dave Chinnerf0a76952010-01-11 11:49:57 +00002831 trans = xlog_recover_find_tid(&rhash[hash], tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 if (trans == NULL) { /* not found; add new tid */
2833 if (ohead->oh_flags & XLOG_START_TRANS)
2834 xlog_recover_new_tid(&rhash[hash], tid,
Christoph Hellwigb53e6752007-10-12 10:59:34 +10002835 be64_to_cpu(rhead->h_lsn));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002836 } else {
Lachlan McIlroy9742bb92008-01-10 16:43:36 +11002837 if (dp + be32_to_cpu(ohead->oh_len) > lp) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002838 xfs_warn(log->l_mp, "%s: bad length 0x%x",
2839 __func__, be32_to_cpu(ohead->oh_len));
Lachlan McIlroy9742bb92008-01-10 16:43:36 +11002840 WARN_ON(1);
2841 return (XFS_ERROR(EIO));
2842 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843 flags = ohead->oh_flags & ~XLOG_END_TRANS;
2844 if (flags & XLOG_WAS_CONT_TRANS)
2845 flags &= ~XLOG_CONTINUE_TRANS;
2846 switch (flags) {
2847 case XLOG_COMMIT_TRANS:
2848 error = xlog_recover_commit_trans(log,
Dave Chinnerf0a76952010-01-11 11:49:57 +00002849 trans, pass);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 break;
2851 case XLOG_UNMOUNT_TRANS:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002852 error = xlog_recover_unmount_trans(log, trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853 break;
2854 case XLOG_WAS_CONT_TRANS:
Dave Chinner9abbc532010-04-13 15:06:46 +10002855 error = xlog_recover_add_to_cont_trans(log,
2856 trans, dp,
2857 be32_to_cpu(ohead->oh_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858 break;
2859 case XLOG_START_TRANS:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002860 xfs_warn(log->l_mp, "%s: bad transaction",
2861 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862 ASSERT(0);
2863 error = XFS_ERROR(EIO);
2864 break;
2865 case 0:
2866 case XLOG_CONTINUE_TRANS:
Dave Chinner9abbc532010-04-13 15:06:46 +10002867 error = xlog_recover_add_to_trans(log, trans,
Christoph Hellwig67fcb7b2007-10-12 10:58:59 +10002868 dp, be32_to_cpu(ohead->oh_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002869 break;
2870 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002871 xfs_warn(log->l_mp, "%s: bad flag 0x%x",
2872 __func__, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873 ASSERT(0);
2874 error = XFS_ERROR(EIO);
2875 break;
2876 }
2877 if (error)
2878 return error;
2879 }
Christoph Hellwig67fcb7b2007-10-12 10:58:59 +10002880 dp += be32_to_cpu(ohead->oh_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 num_logops--;
2882 }
2883 return 0;
2884}
2885
2886/*
2887 * Process an extent free intent item that was recovered from
2888 * the log. We need to free the extents that it describes.
2889 */
David Chinner3c1e2bb2008-04-10 12:21:11 +10002890STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891xlog_recover_process_efi(
2892 xfs_mount_t *mp,
2893 xfs_efi_log_item_t *efip)
2894{
2895 xfs_efd_log_item_t *efdp;
2896 xfs_trans_t *tp;
2897 int i;
David Chinner3c1e2bb2008-04-10 12:21:11 +10002898 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899 xfs_extent_t *extp;
2900 xfs_fsblock_t startblock_fsb;
2901
Dave Chinnerb199c8a2010-12-20 11:59:49 +11002902 ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903
2904 /*
2905 * First check the validity of the extents described by the
2906 * EFI. If any are bad, then assume that all are bad and
2907 * just toss the EFI.
2908 */
2909 for (i = 0; i < efip->efi_format.efi_nextents; i++) {
2910 extp = &(efip->efi_format.efi_extents[i]);
2911 startblock_fsb = XFS_BB_TO_FSB(mp,
2912 XFS_FSB_TO_DADDR(mp, extp->ext_start));
2913 if ((startblock_fsb == 0) ||
2914 (extp->ext_len == 0) ||
2915 (startblock_fsb >= mp->m_sb.sb_dblocks) ||
2916 (extp->ext_len >= mp->m_sb.sb_agblocks)) {
2917 /*
2918 * This will pull the EFI from the AIL and
2919 * free the memory associated with it.
2920 */
2921 xfs_efi_release(efip, efip->efi_format.efi_nextents);
David Chinner3c1e2bb2008-04-10 12:21:11 +10002922 return XFS_ERROR(EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923 }
2924 }
2925
2926 tp = xfs_trans_alloc(mp, 0);
David Chinner3c1e2bb2008-04-10 12:21:11 +10002927 error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0, 0, 0);
David Chinnerfc6149d2008-04-10 12:21:53 +10002928 if (error)
2929 goto abort_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002930 efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
2931
2932 for (i = 0; i < efip->efi_format.efi_nextents; i++) {
2933 extp = &(efip->efi_format.efi_extents[i]);
David Chinnerfc6149d2008-04-10 12:21:53 +10002934 error = xfs_free_extent(tp, extp->ext_start, extp->ext_len);
2935 if (error)
2936 goto abort_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 xfs_trans_log_efd_extent(tp, efdp, extp->ext_start,
2938 extp->ext_len);
2939 }
2940
Dave Chinnerb199c8a2010-12-20 11:59:49 +11002941 set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
David Chinnere5720ee2008-04-10 12:21:18 +10002942 error = xfs_trans_commit(tp, 0);
David Chinner3c1e2bb2008-04-10 12:21:11 +10002943 return error;
David Chinnerfc6149d2008-04-10 12:21:53 +10002944
2945abort_error:
2946 xfs_trans_cancel(tp, XFS_TRANS_ABORT);
2947 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002948}
2949
2950/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951 * When this is called, all of the EFIs which did not have
2952 * corresponding EFDs should be in the AIL. What we do now
2953 * is free the extents associated with each one.
2954 *
2955 * Since we process the EFIs in normal transactions, they
2956 * will be removed at some point after the commit. This prevents
2957 * us from just walking down the list processing each one.
2958 * We'll use a flag in the EFI to skip those that we've already
2959 * processed and use the AIL iteration mechanism's generation
2960 * count to try to speed this up at least a bit.
2961 *
2962 * When we start, we know that the EFIs are the only things in
2963 * the AIL. As we process them, however, other items are added
2964 * to the AIL. Since everything added to the AIL must come after
2965 * everything already in the AIL, we stop processing as soon as
2966 * we see something other than an EFI in the AIL.
2967 */
David Chinner3c1e2bb2008-04-10 12:21:11 +10002968STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969xlog_recover_process_efis(
2970 xlog_t *log)
2971{
2972 xfs_log_item_t *lip;
2973 xfs_efi_log_item_t *efip;
David Chinner3c1e2bb2008-04-10 12:21:11 +10002974 int error = 0;
David Chinner27d8d5f2008-10-30 17:38:39 +11002975 struct xfs_ail_cursor cur;
David Chinnera9c21c12008-10-30 17:39:35 +11002976 struct xfs_ail *ailp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977
David Chinnera9c21c12008-10-30 17:39:35 +11002978 ailp = log->l_ailp;
2979 spin_lock(&ailp->xa_lock);
2980 lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981 while (lip != NULL) {
2982 /*
2983 * We're done when we see something other than an EFI.
David Chinner27d8d5f2008-10-30 17:38:39 +11002984 * There should be no EFIs left in the AIL now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985 */
2986 if (lip->li_type != XFS_LI_EFI) {
David Chinner27d8d5f2008-10-30 17:38:39 +11002987#ifdef DEBUG
David Chinnera9c21c12008-10-30 17:39:35 +11002988 for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
David Chinner27d8d5f2008-10-30 17:38:39 +11002989 ASSERT(lip->li_type != XFS_LI_EFI);
2990#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991 break;
2992 }
2993
2994 /*
2995 * Skip EFIs that we've already processed.
2996 */
2997 efip = (xfs_efi_log_item_t *)lip;
Dave Chinnerb199c8a2010-12-20 11:59:49 +11002998 if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)) {
David Chinnera9c21c12008-10-30 17:39:35 +11002999 lip = xfs_trans_ail_cursor_next(ailp, &cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003000 continue;
3001 }
3002
David Chinnera9c21c12008-10-30 17:39:35 +11003003 spin_unlock(&ailp->xa_lock);
3004 error = xlog_recover_process_efi(log->l_mp, efip);
3005 spin_lock(&ailp->xa_lock);
David Chinner27d8d5f2008-10-30 17:38:39 +11003006 if (error)
3007 goto out;
David Chinnera9c21c12008-10-30 17:39:35 +11003008 lip = xfs_trans_ail_cursor_next(ailp, &cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003009 }
David Chinner27d8d5f2008-10-30 17:38:39 +11003010out:
David Chinnera9c21c12008-10-30 17:39:35 +11003011 xfs_trans_ail_cursor_done(ailp, &cur);
3012 spin_unlock(&ailp->xa_lock);
David Chinner3c1e2bb2008-04-10 12:21:11 +10003013 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014}
3015
3016/*
3017 * This routine performs a transaction to null out a bad inode pointer
3018 * in an agi unlinked inode hash bucket.
3019 */
3020STATIC void
3021xlog_recover_clear_agi_bucket(
3022 xfs_mount_t *mp,
3023 xfs_agnumber_t agno,
3024 int bucket)
3025{
3026 xfs_trans_t *tp;
3027 xfs_agi_t *agi;
3028 xfs_buf_t *agibp;
3029 int offset;
3030 int error;
3031
3032 tp = xfs_trans_alloc(mp, XFS_TRANS_CLEAR_AGI_BUCKET);
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003033 error = xfs_trans_reserve(tp, 0, XFS_CLEAR_AGI_BUCKET_LOG_RES(mp),
3034 0, 0, 0);
David Chinnere5720ee2008-04-10 12:21:18 +10003035 if (error)
3036 goto out_abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003038 error = xfs_read_agi(mp, tp, agno, &agibp);
3039 if (error)
David Chinnere5720ee2008-04-10 12:21:18 +10003040 goto out_abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003042 agi = XFS_BUF_TO_AGI(agibp);
Christoph Hellwig16259e72005-11-02 15:11:25 +11003043 agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 offset = offsetof(xfs_agi_t, agi_unlinked) +
3045 (sizeof(xfs_agino_t) * bucket);
3046 xfs_trans_log_buf(tp, agibp, offset,
3047 (offset + sizeof(xfs_agino_t) - 1));
3048
David Chinnere5720ee2008-04-10 12:21:18 +10003049 error = xfs_trans_commit(tp, 0);
3050 if (error)
3051 goto out_error;
3052 return;
3053
3054out_abort:
3055 xfs_trans_cancel(tp, XFS_TRANS_ABORT);
3056out_error:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003057 xfs_warn(mp, "%s: failed to clear agi %d. Continuing.", __func__, agno);
David Chinnere5720ee2008-04-10 12:21:18 +10003058 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059}
3060
Christoph Hellwig23fac502008-11-28 14:23:40 +11003061STATIC xfs_agino_t
3062xlog_recover_process_one_iunlink(
3063 struct xfs_mount *mp,
3064 xfs_agnumber_t agno,
3065 xfs_agino_t agino,
3066 int bucket)
3067{
3068 struct xfs_buf *ibp;
3069 struct xfs_dinode *dip;
3070 struct xfs_inode *ip;
3071 xfs_ino_t ino;
3072 int error;
3073
3074 ino = XFS_AGINO_TO_INO(mp, agno, agino);
Dave Chinner7b6259e2010-06-24 11:35:17 +10003075 error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003076 if (error)
3077 goto fail;
3078
3079 /*
3080 * Get the on disk inode to find the next inode in the bucket.
3081 */
Christoph Hellwig0cadda12010-01-19 09:56:44 +00003082 error = xfs_itobp(mp, NULL, ip, &dip, &ibp, XBF_LOCK);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003083 if (error)
Christoph Hellwig0e446672008-11-28 14:23:42 +11003084 goto fail_iput;
Christoph Hellwig23fac502008-11-28 14:23:40 +11003085
Christoph Hellwig23fac502008-11-28 14:23:40 +11003086 ASSERT(ip->i_d.di_nlink == 0);
Christoph Hellwig0e446672008-11-28 14:23:42 +11003087 ASSERT(ip->i_d.di_mode != 0);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003088
3089 /* setup for the next pass */
3090 agino = be32_to_cpu(dip->di_next_unlinked);
3091 xfs_buf_relse(ibp);
3092
3093 /*
3094 * Prevent any DMAPI event from being sent when the reference on
3095 * the inode is dropped.
3096 */
3097 ip->i_d.di_dmevmask = 0;
3098
Christoph Hellwig0e446672008-11-28 14:23:42 +11003099 IRELE(ip);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003100 return agino;
3101
Christoph Hellwig0e446672008-11-28 14:23:42 +11003102 fail_iput:
3103 IRELE(ip);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003104 fail:
3105 /*
3106 * We can't read in the inode this bucket points to, or this inode
3107 * is messed up. Just ditch this bucket of inodes. We will lose
3108 * some inodes and space, but at least we won't hang.
3109 *
3110 * Call xlog_recover_clear_agi_bucket() to perform a transaction to
3111 * clear the inode pointer in the bucket.
3112 */
3113 xlog_recover_clear_agi_bucket(mp, agno, bucket);
3114 return NULLAGINO;
3115}
3116
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117/*
3118 * xlog_iunlink_recover
3119 *
3120 * This is called during recovery to process any inodes which
3121 * we unlinked but not freed when the system crashed. These
3122 * inodes will be on the lists in the AGI blocks. What we do
3123 * here is scan all the AGIs and fully truncate and free any
3124 * inodes found on the lists. Each inode is removed from the
3125 * lists when it has been fully truncated and is freed. The
3126 * freeing of the inode and its removal from the list must be
3127 * atomic.
3128 */
Eric Sandeend96f8f82009-07-02 00:09:33 -05003129STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07003130xlog_recover_process_iunlinks(
3131 xlog_t *log)
3132{
3133 xfs_mount_t *mp;
3134 xfs_agnumber_t agno;
3135 xfs_agi_t *agi;
3136 xfs_buf_t *agibp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 xfs_agino_t agino;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138 int bucket;
3139 int error;
3140 uint mp_dmevmask;
3141
3142 mp = log->l_mp;
3143
3144 /*
3145 * Prevent any DMAPI event from being sent while in this function.
3146 */
3147 mp_dmevmask = mp->m_dmevmask;
3148 mp->m_dmevmask = 0;
3149
3150 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
3151 /*
3152 * Find the agi for this ag.
3153 */
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003154 error = xfs_read_agi(mp, NULL, agno, &agibp);
3155 if (error) {
3156 /*
3157 * AGI is b0rked. Don't process it.
3158 *
3159 * We should probably mark the filesystem as corrupt
3160 * after we've recovered all the ag's we can....
3161 */
3162 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163 }
3164 agi = XFS_BUF_TO_AGI(agibp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165
3166 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) {
Christoph Hellwig16259e72005-11-02 15:11:25 +11003167 agino = be32_to_cpu(agi->agi_unlinked[bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003168 while (agino != NULLAGINO) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 /*
3170 * Release the agi buffer so that it can
3171 * be acquired in the normal course of the
3172 * transaction to truncate and free the inode.
3173 */
3174 xfs_buf_relse(agibp);
3175
Christoph Hellwig23fac502008-11-28 14:23:40 +11003176 agino = xlog_recover_process_one_iunlink(mp,
3177 agno, agino, bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178
3179 /*
3180 * Reacquire the agibuffer and continue around
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003181 * the loop. This should never fail as we know
3182 * the buffer was good earlier on.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003183 */
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003184 error = xfs_read_agi(mp, NULL, agno, &agibp);
3185 ASSERT(error == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003186 agi = XFS_BUF_TO_AGI(agibp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187 }
3188 }
3189
3190 /*
3191 * Release the buffer for the current agi so we can
3192 * go on to the next one.
3193 */
3194 xfs_buf_relse(agibp);
3195 }
3196
3197 mp->m_dmevmask = mp_dmevmask;
3198}
3199
3200
3201#ifdef DEBUG
3202STATIC void
3203xlog_pack_data_checksum(
3204 xlog_t *log,
3205 xlog_in_core_t *iclog,
3206 int size)
3207{
3208 int i;
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003209 __be32 *up;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003210 uint chksum = 0;
3211
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003212 up = (__be32 *)iclog->ic_datap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003213 /* divide length by 4 to get # words */
3214 for (i = 0; i < (size >> 2); i++) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003215 chksum ^= be32_to_cpu(*up);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003216 up++;
3217 }
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003218 iclog->ic_header.h_chksum = cpu_to_be32(chksum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003219}
3220#else
3221#define xlog_pack_data_checksum(log, iclog, size)
3222#endif
3223
3224/*
3225 * Stamp cycle number in every block
3226 */
3227void
3228xlog_pack_data(
3229 xlog_t *log,
3230 xlog_in_core_t *iclog,
3231 int roundoff)
3232{
3233 int i, j, k;
3234 int size = iclog->ic_offset + roundoff;
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003235 __be32 cycle_lsn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003236 xfs_caddr_t dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237
3238 xlog_pack_data_checksum(log, iclog, size);
3239
3240 cycle_lsn = CYCLE_LSN_DISK(iclog->ic_header.h_lsn);
3241
3242 dp = iclog->ic_datap;
3243 for (i = 0; i < BTOBB(size) &&
3244 i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003245 iclog->ic_header.h_cycle_data[i] = *(__be32 *)dp;
3246 *(__be32 *)dp = cycle_lsn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247 dp += BBSIZE;
3248 }
3249
Eric Sandeen62118702008-03-06 13:44:28 +11003250 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Christoph Hellwigb28708d2008-11-28 14:23:38 +11003251 xlog_in_core_2_t *xhdr = iclog->ic_data;
3252
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253 for ( ; i < BTOBB(size); i++) {
3254 j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3255 k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003256 xhdr[j].hic_xheader.xh_cycle_data[k] = *(__be32 *)dp;
3257 *(__be32 *)dp = cycle_lsn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003258 dp += BBSIZE;
3259 }
3260
3261 for (i = 1; i < log->l_iclog_heads; i++) {
3262 xhdr[i].hic_xheader.xh_cycle = cycle_lsn;
3263 }
3264 }
3265}
3266
Linus Torvalds1da177e2005-04-16 15:20:36 -07003267STATIC void
3268xlog_unpack_data(
3269 xlog_rec_header_t *rhead,
3270 xfs_caddr_t dp,
3271 xlog_t *log)
3272{
3273 int i, j, k;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003274
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003275 for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003276 i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003277 *(__be32 *)dp = *(__be32 *)&rhead->h_cycle_data[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003278 dp += BBSIZE;
3279 }
3280
Eric Sandeen62118702008-03-06 13:44:28 +11003281 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Christoph Hellwigb28708d2008-11-28 14:23:38 +11003282 xlog_in_core_2_t *xhdr = (xlog_in_core_2_t *)rhead;
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003283 for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284 j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3285 k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003286 *(__be32 *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003287 dp += BBSIZE;
3288 }
3289 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003290}
3291
3292STATIC int
3293xlog_valid_rec_header(
3294 xlog_t *log,
3295 xlog_rec_header_t *rhead,
3296 xfs_daddr_t blkno)
3297{
3298 int hlen;
3299
Christoph Hellwig69ef9212011-07-08 14:36:05 +02003300 if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003301 XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
3302 XFS_ERRLEVEL_LOW, log->l_mp);
3303 return XFS_ERROR(EFSCORRUPTED);
3304 }
3305 if (unlikely(
3306 (!rhead->h_version ||
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003307 (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003308 xfs_warn(log->l_mp, "%s: unrecognised log version (%d).",
Harvey Harrison34a622b2008-04-10 12:19:21 +10003309 __func__, be32_to_cpu(rhead->h_version));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310 return XFS_ERROR(EIO);
3311 }
3312
3313 /* LR body must have data or it wouldn't have been written */
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003314 hlen = be32_to_cpu(rhead->h_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003315 if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
3316 XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
3317 XFS_ERRLEVEL_LOW, log->l_mp);
3318 return XFS_ERROR(EFSCORRUPTED);
3319 }
3320 if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
3321 XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
3322 XFS_ERRLEVEL_LOW, log->l_mp);
3323 return XFS_ERROR(EFSCORRUPTED);
3324 }
3325 return 0;
3326}
3327
3328/*
3329 * Read the log from tail to head and process the log records found.
3330 * Handle the two cases where the tail and head are in the same cycle
3331 * and where the active portion of the log wraps around the end of
3332 * the physical log separately. The pass parameter is passed through
3333 * to the routines called to process the data and is not looked at
3334 * here.
3335 */
3336STATIC int
3337xlog_do_recovery_pass(
3338 xlog_t *log,
3339 xfs_daddr_t head_blk,
3340 xfs_daddr_t tail_blk,
3341 int pass)
3342{
3343 xlog_rec_header_t *rhead;
3344 xfs_daddr_t blk_no;
Andy Polingfc5bc4c2009-11-03 17:26:47 +00003345 xfs_caddr_t offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003346 xfs_buf_t *hbp, *dbp;
3347 int error = 0, h_size;
3348 int bblks, split_bblks;
3349 int hblks, split_hblks, wrapped_hblks;
Dave Chinnerf0a76952010-01-11 11:49:57 +00003350 struct hlist_head rhash[XLOG_RHASH_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003351
3352 ASSERT(head_blk != tail_blk);
3353
3354 /*
3355 * Read the header of the tail block and get the iclog buffer size from
3356 * h_size. Use this to tell how many sectors make up the log header.
3357 */
Eric Sandeen62118702008-03-06 13:44:28 +11003358 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003359 /*
3360 * When using variable length iclogs, read first sector of
3361 * iclog header and extract the header size from it. Get a
3362 * new hbp that is the correct size.
3363 */
3364 hbp = xlog_get_bp(log, 1);
3365 if (!hbp)
3366 return ENOMEM;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003367
3368 error = xlog_bread(log, tail_blk, 1, hbp, &offset);
3369 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370 goto bread_err1;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003371
Linus Torvalds1da177e2005-04-16 15:20:36 -07003372 rhead = (xlog_rec_header_t *)offset;
3373 error = xlog_valid_rec_header(log, rhead, tail_blk);
3374 if (error)
3375 goto bread_err1;
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003376 h_size = be32_to_cpu(rhead->h_size);
3377 if ((be32_to_cpu(rhead->h_version) & XLOG_VERSION_2) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003378 (h_size > XLOG_HEADER_CYCLE_SIZE)) {
3379 hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
3380 if (h_size % XLOG_HEADER_CYCLE_SIZE)
3381 hblks++;
3382 xlog_put_bp(hbp);
3383 hbp = xlog_get_bp(log, hblks);
3384 } else {
3385 hblks = 1;
3386 }
3387 } else {
Alex Elder69ce58f2010-04-20 17:09:59 +10003388 ASSERT(log->l_sectBBsize == 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003389 hblks = 1;
3390 hbp = xlog_get_bp(log, 1);
3391 h_size = XLOG_BIG_RECORD_BSIZE;
3392 }
3393
3394 if (!hbp)
3395 return ENOMEM;
3396 dbp = xlog_get_bp(log, BTOBB(h_size));
3397 if (!dbp) {
3398 xlog_put_bp(hbp);
3399 return ENOMEM;
3400 }
3401
3402 memset(rhash, 0, sizeof(rhash));
3403 if (tail_blk <= head_blk) {
3404 for (blk_no = tail_blk; blk_no < head_blk; ) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003405 error = xlog_bread(log, blk_no, hblks, hbp, &offset);
3406 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003407 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003408
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409 rhead = (xlog_rec_header_t *)offset;
3410 error = xlog_valid_rec_header(log, rhead, blk_no);
3411 if (error)
3412 goto bread_err2;
3413
3414 /* blocks in data section */
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003415 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003416 error = xlog_bread(log, blk_no + hblks, bblks, dbp,
3417 &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003418 if (error)
3419 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003420
Linus Torvalds1da177e2005-04-16 15:20:36 -07003421 xlog_unpack_data(rhead, offset, log);
3422 if ((error = xlog_recover_process_data(log,
3423 rhash, rhead, offset, pass)))
3424 goto bread_err2;
3425 blk_no += bblks + hblks;
3426 }
3427 } else {
3428 /*
3429 * Perform recovery around the end of the physical log.
3430 * When the head is not on the same cycle number as the tail,
3431 * we can't do a sequential recovery as above.
3432 */
3433 blk_no = tail_blk;
3434 while (blk_no < log->l_logBBsize) {
3435 /*
3436 * Check for header wrapping around physical end-of-log
3437 */
Chandra Seetharaman62926042011-07-22 23:40:15 +00003438 offset = hbp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003439 split_hblks = 0;
3440 wrapped_hblks = 0;
3441 if (blk_no + hblks <= log->l_logBBsize) {
3442 /* Read header in one read */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003443 error = xlog_bread(log, blk_no, hblks, hbp,
3444 &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003445 if (error)
3446 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003447 } else {
3448 /* This LR is split across physical log end */
3449 if (blk_no != log->l_logBBsize) {
3450 /* some data before physical log end */
3451 ASSERT(blk_no <= INT_MAX);
3452 split_hblks = log->l_logBBsize - (int)blk_no;
3453 ASSERT(split_hblks > 0);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003454 error = xlog_bread(log, blk_no,
3455 split_hblks, hbp,
3456 &offset);
3457 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003458 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459 }
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003460
Linus Torvalds1da177e2005-04-16 15:20:36 -07003461 /*
3462 * Note: this black magic still works with
3463 * large sector sizes (non-512) only because:
3464 * - we increased the buffer size originally
3465 * by 1 sector giving us enough extra space
3466 * for the second read;
3467 * - the log start is guaranteed to be sector
3468 * aligned;
3469 * - we read the log end (LR header start)
3470 * _first_, then the log start (LR header end)
3471 * - order is important.
3472 */
David Chinner234f56a2008-04-10 12:24:24 +10003473 wrapped_hblks = hblks - split_hblks;
Dave Chinner44396472011-04-21 09:34:27 +00003474 error = xlog_bread_offset(log, 0,
3475 wrapped_hblks, hbp,
3476 offset + BBTOB(split_hblks));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477 if (error)
3478 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003479 }
3480 rhead = (xlog_rec_header_t *)offset;
3481 error = xlog_valid_rec_header(log, rhead,
3482 split_hblks ? blk_no : 0);
3483 if (error)
3484 goto bread_err2;
3485
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003486 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487 blk_no += hblks;
3488
3489 /* Read in data for log record */
3490 if (blk_no + bblks <= log->l_logBBsize) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003491 error = xlog_bread(log, blk_no, bblks, dbp,
3492 &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493 if (error)
3494 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495 } else {
3496 /* This log record is split across the
3497 * physical end of log */
Chandra Seetharaman62926042011-07-22 23:40:15 +00003498 offset = dbp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499 split_bblks = 0;
3500 if (blk_no != log->l_logBBsize) {
3501 /* some data is before the physical
3502 * end of log */
3503 ASSERT(!wrapped_hblks);
3504 ASSERT(blk_no <= INT_MAX);
3505 split_bblks =
3506 log->l_logBBsize - (int)blk_no;
3507 ASSERT(split_bblks > 0);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003508 error = xlog_bread(log, blk_no,
3509 split_bblks, dbp,
3510 &offset);
3511 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003512 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003513 }
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003514
Linus Torvalds1da177e2005-04-16 15:20:36 -07003515 /*
3516 * Note: this black magic still works with
3517 * large sector sizes (non-512) only because:
3518 * - we increased the buffer size originally
3519 * by 1 sector giving us enough extra space
3520 * for the second read;
3521 * - the log start is guaranteed to be sector
3522 * aligned;
3523 * - we read the log end (LR header start)
3524 * _first_, then the log start (LR header end)
3525 * - order is important.
3526 */
Dave Chinner44396472011-04-21 09:34:27 +00003527 error = xlog_bread_offset(log, 0,
3528 bblks - split_bblks, hbp,
3529 offset + BBTOB(split_bblks));
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003530 if (error)
3531 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003532 }
3533 xlog_unpack_data(rhead, offset, log);
3534 if ((error = xlog_recover_process_data(log, rhash,
3535 rhead, offset, pass)))
3536 goto bread_err2;
3537 blk_no += bblks;
3538 }
3539
3540 ASSERT(blk_no >= log->l_logBBsize);
3541 blk_no -= log->l_logBBsize;
3542
3543 /* read first part of physical log */
3544 while (blk_no < head_blk) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003545 error = xlog_bread(log, blk_no, hblks, hbp, &offset);
3546 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003547 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003548
Linus Torvalds1da177e2005-04-16 15:20:36 -07003549 rhead = (xlog_rec_header_t *)offset;
3550 error = xlog_valid_rec_header(log, rhead, blk_no);
3551 if (error)
3552 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003553
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003554 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003555 error = xlog_bread(log, blk_no+hblks, bblks, dbp,
3556 &offset);
3557 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003558 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003559
Linus Torvalds1da177e2005-04-16 15:20:36 -07003560 xlog_unpack_data(rhead, offset, log);
3561 if ((error = xlog_recover_process_data(log, rhash,
3562 rhead, offset, pass)))
3563 goto bread_err2;
3564 blk_no += bblks + hblks;
3565 }
3566 }
3567
3568 bread_err2:
3569 xlog_put_bp(dbp);
3570 bread_err1:
3571 xlog_put_bp(hbp);
3572 return error;
3573}
3574
3575/*
3576 * Do the recovery of the log. We actually do this in two phases.
3577 * The two passes are necessary in order to implement the function
3578 * of cancelling a record written into the log. The first pass
3579 * determines those things which have been cancelled, and the
3580 * second pass replays log items normally except for those which
3581 * have been cancelled. The handling of the replay and cancellations
3582 * takes place in the log item type specific routines.
3583 *
3584 * The table of items which have cancel records in the log is allocated
3585 * and freed at this level, since only here do we know when all of
3586 * the log recovery has been completed.
3587 */
3588STATIC int
3589xlog_do_log_recovery(
3590 xlog_t *log,
3591 xfs_daddr_t head_blk,
3592 xfs_daddr_t tail_blk)
3593{
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00003594 int error, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595
3596 ASSERT(head_blk != tail_blk);
3597
3598 /*
3599 * First do a pass to find all of the cancelled buf log items.
3600 * Store them in the buf_cancel_table for use in the second pass.
3601 */
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00003602 log->l_buf_cancel_table = kmem_zalloc(XLOG_BC_TABLE_SIZE *
3603 sizeof(struct list_head),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003604 KM_SLEEP);
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00003605 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
3606 INIT_LIST_HEAD(&log->l_buf_cancel_table[i]);
3607
Linus Torvalds1da177e2005-04-16 15:20:36 -07003608 error = xlog_do_recovery_pass(log, head_blk, tail_blk,
3609 XLOG_RECOVER_PASS1);
3610 if (error != 0) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10003611 kmem_free(log->l_buf_cancel_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003612 log->l_buf_cancel_table = NULL;
3613 return error;
3614 }
3615 /*
3616 * Then do a second pass to actually recover the items in the log.
3617 * When it is complete free the table of buf cancel items.
3618 */
3619 error = xlog_do_recovery_pass(log, head_blk, tail_blk,
3620 XLOG_RECOVER_PASS2);
3621#ifdef DEBUG
Tim Shimmin6d192a92006-06-09 14:55:38 +10003622 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003623 int i;
3624
3625 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00003626 ASSERT(list_empty(&log->l_buf_cancel_table[i]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003627 }
3628#endif /* DEBUG */
3629
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10003630 kmem_free(log->l_buf_cancel_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003631 log->l_buf_cancel_table = NULL;
3632
3633 return error;
3634}
3635
3636/*
3637 * Do the actual recovery
3638 */
3639STATIC int
3640xlog_do_recover(
3641 xlog_t *log,
3642 xfs_daddr_t head_blk,
3643 xfs_daddr_t tail_blk)
3644{
3645 int error;
3646 xfs_buf_t *bp;
3647 xfs_sb_t *sbp;
3648
3649 /*
3650 * First replay the images in the log.
3651 */
3652 error = xlog_do_log_recovery(log, head_blk, tail_blk);
3653 if (error) {
3654 return error;
3655 }
3656
Christoph Hellwiga9add832011-10-10 16:52:52 +00003657 xfs_flush_buftarg(log->l_mp->m_ddev_targp, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003658
3659 /*
3660 * If IO errors happened during recovery, bail out.
3661 */
3662 if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
3663 return (EIO);
3664 }
3665
3666 /*
3667 * We now update the tail_lsn since much of the recovery has completed
3668 * and there may be space available to use. If there were no extent
3669 * or iunlinks, we can free up the entire log and set the tail_lsn to
3670 * be the last_sync_lsn. This was set in xlog_find_tail to be the
3671 * lsn of the last known good LR on disk. If there are extent frees
3672 * or iunlinks they will have some entries in the AIL; so we look at
3673 * the AIL to determine how to set the tail_lsn.
3674 */
3675 xlog_assign_tail_lsn(log->l_mp);
3676
3677 /*
3678 * Now that we've finished replaying all buffer and inode
3679 * updates, re-read in the superblock.
3680 */
3681 bp = xfs_getsb(log->l_mp, 0);
3682 XFS_BUF_UNDONE(bp);
Lachlan McIlroybebf9632007-10-15 13:18:02 +10003683 ASSERT(!(XFS_BUF_ISWRITE(bp)));
3684 ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003685 XFS_BUF_READ(bp);
Lachlan McIlroybebf9632007-10-15 13:18:02 +10003686 XFS_BUF_UNASYNC(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003687 xfsbdstrat(log->l_mp, bp);
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +00003688 error = xfs_buf_iowait(bp);
David Chinnerd64e31a2008-04-10 12:22:17 +10003689 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +00003690 xfs_buf_ioerror_alert(bp, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003691 ASSERT(0);
3692 xfs_buf_relse(bp);
3693 return error;
3694 }
3695
3696 /* Convert superblock from on-disk format */
3697 sbp = &log->l_mp->m_sb;
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +10003698 xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003699 ASSERT(sbp->sb_magicnum == XFS_SB_MAGIC);
Eric Sandeen62118702008-03-06 13:44:28 +11003700 ASSERT(xfs_sb_good_version(sbp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003701 xfs_buf_relse(bp);
3702
Lachlan McIlroy5478eea2007-02-10 18:36:29 +11003703 /* We've re-read the superblock so re-initialize per-cpu counters */
3704 xfs_icsb_reinit_counters(log->l_mp);
3705
Linus Torvalds1da177e2005-04-16 15:20:36 -07003706 xlog_recover_check_summary(log);
3707
3708 /* Normal transactions can now occur */
3709 log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
3710 return 0;
3711}
3712
3713/*
3714 * Perform recovery and re-initialize some log variables in xlog_find_tail.
3715 *
3716 * Return error or zero.
3717 */
3718int
3719xlog_recover(
Eric Sandeen65be6052006-01-11 15:34:19 +11003720 xlog_t *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003721{
3722 xfs_daddr_t head_blk, tail_blk;
3723 int error;
3724
3725 /* find the tail of the log */
Eric Sandeen65be6052006-01-11 15:34:19 +11003726 if ((error = xlog_find_tail(log, &head_blk, &tail_blk)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003727 return error;
3728
3729 if (tail_blk != head_blk) {
3730 /* There used to be a comment here:
3731 *
3732 * disallow recovery on read-only mounts. note -- mount
3733 * checks for ENOSPC and turns it into an intelligent
3734 * error message.
3735 * ...but this is no longer true. Now, unless you specify
3736 * NORECOVERY (in which case this function would never be
3737 * called), we just go ahead and recover. We do this all
3738 * under the vfs layer, so we can get away with it unless
3739 * the device itself is read-only, in which case we fail.
3740 */
Utako Kusaka3a02ee12007-05-08 13:50:06 +10003741 if ((error = xfs_dev_is_read_only(log->l_mp, "recovery"))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003742 return error;
3743 }
3744
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003745 xfs_notice(log->l_mp, "Starting recovery (logdev: %s)",
3746 log->l_mp->m_logname ? log->l_mp->m_logname
3747 : "internal");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003748
3749 error = xlog_do_recover(log, head_blk, tail_blk);
3750 log->l_flags |= XLOG_RECOVERY_NEEDED;
3751 }
3752 return error;
3753}
3754
3755/*
3756 * In the first part of recovery we replay inodes and buffers and build
3757 * up the list of extent free items which need to be processed. Here
3758 * we process the extent free items and clean up the on disk unlinked
3759 * inode lists. This is separated from the first part of recovery so
3760 * that the root and real-time bitmap inodes can be read in from disk in
3761 * between the two stages. This is necessary so that we can free space
3762 * in the real-time portion of the file system.
3763 */
3764int
3765xlog_recover_finish(
Christoph Hellwig42490232008-08-13 16:49:32 +10003766 xlog_t *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003767{
3768 /*
3769 * Now we're ready to do the transactions needed for the
3770 * rest of recovery. Start with completing all the extent
3771 * free intent records and then process the unlinked inode
3772 * lists. At this point, we essentially run in normal mode
3773 * except that we're still performing recovery actions
3774 * rather than accepting new requests.
3775 */
3776 if (log->l_flags & XLOG_RECOVERY_NEEDED) {
David Chinner3c1e2bb2008-04-10 12:21:11 +10003777 int error;
3778 error = xlog_recover_process_efis(log);
3779 if (error) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003780 xfs_alert(log->l_mp, "Failed to recover EFIs");
David Chinner3c1e2bb2008-04-10 12:21:11 +10003781 return error;
3782 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003783 /*
3784 * Sync the log to get all the EFIs out of the AIL.
3785 * This isn't absolutely necessary, but it helps in
3786 * case the unlink transactions would have problems
3787 * pushing the EFIs out of the way.
3788 */
Christoph Hellwiga14a3482010-01-19 09:56:46 +00003789 xfs_log_force(log->l_mp, XFS_LOG_SYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003790
Christoph Hellwig42490232008-08-13 16:49:32 +10003791 xlog_recover_process_iunlinks(log);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003792
3793 xlog_recover_check_summary(log);
3794
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003795 xfs_notice(log->l_mp, "Ending recovery (logdev: %s)",
3796 log->l_mp->m_logname ? log->l_mp->m_logname
3797 : "internal");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003798 log->l_flags &= ~XLOG_RECOVERY_NEEDED;
3799 } else {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003800 xfs_info(log->l_mp, "Ending clean mount");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003801 }
3802 return 0;
3803}
3804
3805
3806#if defined(DEBUG)
3807/*
3808 * Read all of the agf and agi counters and check that they
3809 * are consistent with the superblock counters.
3810 */
3811void
3812xlog_recover_check_summary(
3813 xlog_t *log)
3814{
3815 xfs_mount_t *mp;
3816 xfs_agf_t *agfp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003817 xfs_buf_t *agfbp;
3818 xfs_buf_t *agibp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003819 xfs_agnumber_t agno;
3820 __uint64_t freeblks;
3821 __uint64_t itotal;
3822 __uint64_t ifree;
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003823 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003824
3825 mp = log->l_mp;
3826
3827 freeblks = 0LL;
3828 itotal = 0LL;
3829 ifree = 0LL;
3830 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
From: Christoph Hellwig48056212008-11-28 14:23:38 +11003831 error = xfs_read_agf(mp, NULL, agno, 0, &agfbp);
3832 if (error) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003833 xfs_alert(mp, "%s agf read failed agno %d error %d",
3834 __func__, agno, error);
From: Christoph Hellwig48056212008-11-28 14:23:38 +11003835 } else {
3836 agfp = XFS_BUF_TO_AGF(agfbp);
3837 freeblks += be32_to_cpu(agfp->agf_freeblks) +
3838 be32_to_cpu(agfp->agf_flcount);
3839 xfs_buf_relse(agfbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003840 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003841
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003842 error = xfs_read_agi(mp, NULL, agno, &agibp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003843 if (error) {
3844 xfs_alert(mp, "%s agi read failed agno %d error %d",
3845 __func__, agno, error);
3846 } else {
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003847 struct xfs_agi *agi = XFS_BUF_TO_AGI(agibp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003848
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003849 itotal += be32_to_cpu(agi->agi_count);
3850 ifree += be32_to_cpu(agi->agi_freecount);
3851 xfs_buf_relse(agibp);
3852 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003853 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003854}
3855#endif /* DEBUG */