xfs: Check buffer lengths in log recovery
[linux-2.6.git] / fs / xfs / xfs_log_recover.c
1 /*
2  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * 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.
13  *
14  * 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
17  */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_types.h"
21 #include "xfs_bit.h"
22 #include "xfs_log.h"
23 #include "xfs_inum.h"
24 #include "xfs_trans.h"
25 #include "xfs_sb.h"
26 #include "xfs_ag.h"
27 #include "xfs_dir2.h"
28 #include "xfs_dmapi.h"
29 #include "xfs_mount.h"
30 #include "xfs_error.h"
31 #include "xfs_bmap_btree.h"
32 #include "xfs_alloc_btree.h"
33 #include "xfs_ialloc_btree.h"
34 #include "xfs_dir2_sf.h"
35 #include "xfs_attr_sf.h"
36 #include "xfs_dinode.h"
37 #include "xfs_inode.h"
38 #include "xfs_inode_item.h"
39 #include "xfs_alloc.h"
40 #include "xfs_ialloc.h"
41 #include "xfs_log_priv.h"
42 #include "xfs_buf_item.h"
43 #include "xfs_log_recover.h"
44 #include "xfs_extfree_item.h"
45 #include "xfs_trans_priv.h"
46 #include "xfs_quota.h"
47 #include "xfs_rw.h"
48 #include "xfs_utils.h"
49
50 STATIC int      xlog_find_zeroed(xlog_t *, xfs_daddr_t *);
51 STATIC int      xlog_clear_stale_blocks(xlog_t *, xfs_lsn_t);
52 STATIC void     xlog_recover_insert_item_backq(xlog_recover_item_t **q,
53                                                xlog_recover_item_t *item);
54 #if defined(DEBUG)
55 STATIC void     xlog_recover_check_summary(xlog_t *);
56 #else
57 #define xlog_recover_check_summary(log)
58 #endif
59
60
61 /*
62  * Sector aligned buffer routines for buffer create/read/write/access
63  */
64
65 #define XLOG_SECTOR_ROUNDUP_BBCOUNT(log, bbs)   \
66         ( ((log)->l_sectbb_mask && (bbs & (log)->l_sectbb_mask)) ? \
67         ((bbs + (log)->l_sectbb_mask + 1) & ~(log)->l_sectbb_mask) : (bbs) )
68 #define XLOG_SECTOR_ROUNDDOWN_BLKNO(log, bno)   ((bno) & ~(log)->l_sectbb_mask)
69
70 xfs_buf_t *
71 xlog_get_bp(
72         xlog_t          *log,
73         int             nbblks)
74 {
75         if (nbblks <= 0 || nbblks > log->l_logBBsize) {
76                 xlog_warn("XFS: Invalid block length (0x%x) given for buffer", nbblks);
77                 XFS_ERROR_REPORT("xlog_get_bp(1)",
78                                  XFS_ERRLEVEL_HIGH, log->l_mp);
79                 return NULL;
80         }
81
82         if (log->l_sectbb_log) {
83                 if (nbblks > 1)
84                         nbblks += XLOG_SECTOR_ROUNDUP_BBCOUNT(log, 1);
85                 nbblks = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, nbblks);
86         }
87         return xfs_buf_get_noaddr(BBTOB(nbblks), log->l_mp->m_logdev_targp);
88 }
89
90 void
91 xlog_put_bp(
92         xfs_buf_t       *bp)
93 {
94         xfs_buf_free(bp);
95 }
96
97
98 /*
99  * nbblks should be uint, but oh well.  Just want to catch that 32-bit length.
100  */
101 int
102 xlog_bread(
103         xlog_t          *log,
104         xfs_daddr_t     blk_no,
105         int             nbblks,
106         xfs_buf_t       *bp)
107 {
108         int             error;
109
110         if (nbblks <= 0 || nbblks > log->l_logBBsize) {
111                 xlog_warn("XFS: Invalid block length (0x%x) given for buffer", nbblks);
112                 XFS_ERROR_REPORT("xlog_bread(1)",
113                                  XFS_ERRLEVEL_HIGH, log->l_mp);
114                 return EFSCORRUPTED;
115         }
116
117         if (log->l_sectbb_log) {
118                 blk_no = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, blk_no);
119                 nbblks = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, nbblks);
120         }
121
122         ASSERT(nbblks > 0);
123         ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));
124         ASSERT(bp);
125
126         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
127         XFS_BUF_READ(bp);
128         XFS_BUF_BUSY(bp);
129         XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
130         XFS_BUF_SET_TARGET(bp, log->l_mp->m_logdev_targp);
131
132         xfsbdstrat(log->l_mp, bp);
133         error = xfs_iowait(bp);
134         if (error)
135                 xfs_ioerror_alert("xlog_bread", log->l_mp,
136                                   bp, XFS_BUF_ADDR(bp));
137         return error;
138 }
139
140 /*
141  * Write out the buffer at the given block for the given number of blocks.
142  * The buffer is kept locked across the write and is returned locked.
143  * This can only be used for synchronous log writes.
144  */
145 STATIC int
146 xlog_bwrite(
147         xlog_t          *log,
148         xfs_daddr_t     blk_no,
149         int             nbblks,
150         xfs_buf_t       *bp)
151 {
152         int             error;
153
154         if (nbblks <= 0 || nbblks > log->l_logBBsize) {
155                 xlog_warn("XFS: Invalid block length (0x%x) given for buffer", nbblks);
156                 XFS_ERROR_REPORT("xlog_bwrite(1)",
157                                  XFS_ERRLEVEL_HIGH, log->l_mp);
158                 return EFSCORRUPTED;
159         }
160
161         if (log->l_sectbb_log) {
162                 blk_no = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, blk_no);
163                 nbblks = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, nbblks);
164         }
165
166         ASSERT(nbblks > 0);
167         ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));
168
169         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
170         XFS_BUF_ZEROFLAGS(bp);
171         XFS_BUF_BUSY(bp);
172         XFS_BUF_HOLD(bp);
173         XFS_BUF_PSEMA(bp, PRIBIO);
174         XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
175         XFS_BUF_SET_TARGET(bp, log->l_mp->m_logdev_targp);
176
177         if ((error = xfs_bwrite(log->l_mp, bp)))
178                 xfs_ioerror_alert("xlog_bwrite", log->l_mp,
179                                   bp, XFS_BUF_ADDR(bp));
180         return error;
181 }
182
183 STATIC xfs_caddr_t
184 xlog_align(
185         xlog_t          *log,
186         xfs_daddr_t     blk_no,
187         int             nbblks,
188         xfs_buf_t       *bp)
189 {
190         xfs_caddr_t     ptr;
191
192         if (!log->l_sectbb_log)
193                 return XFS_BUF_PTR(bp);
194
195         ptr = XFS_BUF_PTR(bp) + BBTOB((int)blk_no & log->l_sectbb_mask);
196         ASSERT(XFS_BUF_SIZE(bp) >=
197                 BBTOB(nbblks + (blk_no & log->l_sectbb_mask)));
198         return ptr;
199 }
200
201 #ifdef DEBUG
202 /*
203  * dump debug superblock and log record information
204  */
205 STATIC void
206 xlog_header_check_dump(
207         xfs_mount_t             *mp,
208         xlog_rec_header_t       *head)
209 {
210         int                     b;
211
212         cmn_err(CE_DEBUG, "%s:  SB : uuid = ", __func__);
213         for (b = 0; b < 16; b++)
214                 cmn_err(CE_DEBUG, "%02x", ((uchar_t *)&mp->m_sb.sb_uuid)[b]);
215         cmn_err(CE_DEBUG, ", fmt = %d\n", XLOG_FMT);
216         cmn_err(CE_DEBUG, "    log : uuid = ");
217         for (b = 0; b < 16; b++)
218                 cmn_err(CE_DEBUG, "%02x",((uchar_t *)&head->h_fs_uuid)[b]);
219         cmn_err(CE_DEBUG, ", fmt = %d\n", be32_to_cpu(head->h_fmt));
220 }
221 #else
222 #define xlog_header_check_dump(mp, head)
223 #endif
224
225 /*
226  * check log record header for recovery
227  */
228 STATIC int
229 xlog_header_check_recover(
230         xfs_mount_t             *mp,
231         xlog_rec_header_t       *head)
232 {
233         ASSERT(be32_to_cpu(head->h_magicno) == XLOG_HEADER_MAGIC_NUM);
234
235         /*
236          * IRIX doesn't write the h_fmt field and leaves it zeroed
237          * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
238          * a dirty log created in IRIX.
239          */
240         if (unlikely(be32_to_cpu(head->h_fmt) != XLOG_FMT)) {
241                 xlog_warn(
242         "XFS: dirty log written in incompatible format - can't recover");
243                 xlog_header_check_dump(mp, head);
244                 XFS_ERROR_REPORT("xlog_header_check_recover(1)",
245                                  XFS_ERRLEVEL_HIGH, mp);
246                 return XFS_ERROR(EFSCORRUPTED);
247         } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
248                 xlog_warn(
249         "XFS: dirty log entry has mismatched uuid - can't recover");
250                 xlog_header_check_dump(mp, head);
251                 XFS_ERROR_REPORT("xlog_header_check_recover(2)",
252                                  XFS_ERRLEVEL_HIGH, mp);
253                 return XFS_ERROR(EFSCORRUPTED);
254         }
255         return 0;
256 }
257
258 /*
259  * read the head block of the log and check the header
260  */
261 STATIC int
262 xlog_header_check_mount(
263         xfs_mount_t             *mp,
264         xlog_rec_header_t       *head)
265 {
266         ASSERT(be32_to_cpu(head->h_magicno) == XLOG_HEADER_MAGIC_NUM);
267
268         if (uuid_is_nil(&head->h_fs_uuid)) {
269                 /*
270                  * IRIX doesn't write the h_fs_uuid or h_fmt fields. If
271                  * h_fs_uuid is nil, we assume this log was last mounted
272                  * by IRIX and continue.
273                  */
274                 xlog_warn("XFS: nil uuid in log - IRIX style log");
275         } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
276                 xlog_warn("XFS: log has mismatched uuid - can't recover");
277                 xlog_header_check_dump(mp, head);
278                 XFS_ERROR_REPORT("xlog_header_check_mount",
279                                  XFS_ERRLEVEL_HIGH, mp);
280                 return XFS_ERROR(EFSCORRUPTED);
281         }
282         return 0;
283 }
284
285 STATIC void
286 xlog_recover_iodone(
287         struct xfs_buf  *bp)
288 {
289         if (XFS_BUF_GETERROR(bp)) {
290                 /*
291                  * We're not going to bother about retrying
292                  * this during recovery. One strike!
293                  */
294                 xfs_ioerror_alert("xlog_recover_iodone",
295                                   bp->b_mount, bp, XFS_BUF_ADDR(bp));
296                 xfs_force_shutdown(bp->b_mount, SHUTDOWN_META_IO_ERROR);
297         }
298         bp->b_mount = NULL;
299         XFS_BUF_CLR_IODONE_FUNC(bp);
300         xfs_biodone(bp);
301 }
302
303 /*
304  * This routine finds (to an approximation) the first block in the physical
305  * log which contains the given cycle.  It uses a binary search algorithm.
306  * Note that the algorithm can not be perfect because the disk will not
307  * necessarily be perfect.
308  */
309 STATIC int
310 xlog_find_cycle_start(
311         xlog_t          *log,
312         xfs_buf_t       *bp,
313         xfs_daddr_t     first_blk,
314         xfs_daddr_t     *last_blk,
315         uint            cycle)
316 {
317         xfs_caddr_t     offset;
318         xfs_daddr_t     mid_blk;
319         uint            mid_cycle;
320         int             error;
321
322         mid_blk = BLK_AVG(first_blk, *last_blk);
323         while (mid_blk != first_blk && mid_blk != *last_blk) {
324                 if ((error = xlog_bread(log, mid_blk, 1, bp)))
325                         return error;
326                 offset = xlog_align(log, mid_blk, 1, bp);
327                 mid_cycle = xlog_get_cycle(offset);
328                 if (mid_cycle == cycle) {
329                         *last_blk = mid_blk;
330                         /* last_half_cycle == mid_cycle */
331                 } else {
332                         first_blk = mid_blk;
333                         /* first_half_cycle == mid_cycle */
334                 }
335                 mid_blk = BLK_AVG(first_blk, *last_blk);
336         }
337         ASSERT((mid_blk == first_blk && mid_blk+1 == *last_blk) ||
338                (mid_blk == *last_blk && mid_blk-1 == first_blk));
339
340         return 0;
341 }
342
343 /*
344  * Check that the range of blocks does not contain the cycle number
345  * given.  The scan needs to occur from front to back and the ptr into the
346  * region must be updated since a later routine will need to perform another
347  * test.  If the region is completely good, we end up returning the same
348  * last block number.
349  *
350  * Set blkno to -1 if we encounter no errors.  This is an invalid block number
351  * since we don't ever expect logs to get this large.
352  */
353 STATIC int
354 xlog_find_verify_cycle(
355         xlog_t          *log,
356         xfs_daddr_t     start_blk,
357         int             nbblks,
358         uint            stop_on_cycle_no,
359         xfs_daddr_t     *new_blk)
360 {
361         xfs_daddr_t     i, j;
362         uint            cycle;
363         xfs_buf_t       *bp;
364         xfs_daddr_t     bufblks;
365         xfs_caddr_t     buf = NULL;
366         int             error = 0;
367
368         bufblks = 1 << ffs(nbblks);
369
370         while (!(bp = xlog_get_bp(log, bufblks))) {
371                 /* can't get enough memory to do everything in one big buffer */
372                 bufblks >>= 1;
373                 if (bufblks <= log->l_sectbb_log)
374                         return ENOMEM;
375         }
376
377         for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
378                 int     bcount;
379
380                 bcount = min(bufblks, (start_blk + nbblks - i));
381
382                 if ((error = xlog_bread(log, i, bcount, bp)))
383                         goto out;
384
385                 buf = xlog_align(log, i, bcount, bp);
386                 for (j = 0; j < bcount; j++) {
387                         cycle = xlog_get_cycle(buf);
388                         if (cycle == stop_on_cycle_no) {
389                                 *new_blk = i+j;
390                                 goto out;
391                         }
392
393                         buf += BBSIZE;
394                 }
395         }
396
397         *new_blk = -1;
398
399 out:
400         xlog_put_bp(bp);
401         return error;
402 }
403
404 /*
405  * Potentially backup over partial log record write.
406  *
407  * In the typical case, last_blk is the number of the block directly after
408  * a good log record.  Therefore, we subtract one to get the block number
409  * of the last block in the given buffer.  extra_bblks contains the number
410  * of blocks we would have read on a previous read.  This happens when the
411  * last log record is split over the end of the physical log.
412  *
413  * extra_bblks is the number of blocks potentially verified on a previous
414  * call to this routine.
415  */
416 STATIC int
417 xlog_find_verify_log_record(
418         xlog_t                  *log,
419         xfs_daddr_t             start_blk,
420         xfs_daddr_t             *last_blk,
421         int                     extra_bblks)
422 {
423         xfs_daddr_t             i;
424         xfs_buf_t               *bp;
425         xfs_caddr_t             offset = NULL;
426         xlog_rec_header_t       *head = NULL;
427         int                     error = 0;
428         int                     smallmem = 0;
429         int                     num_blks = *last_blk - start_blk;
430         int                     xhdrs;
431
432         ASSERT(start_blk != 0 || *last_blk != start_blk);
433
434         if (!(bp = xlog_get_bp(log, num_blks))) {
435                 if (!(bp = xlog_get_bp(log, 1)))
436                         return ENOMEM;
437                 smallmem = 1;
438         } else {
439                 if ((error = xlog_bread(log, start_blk, num_blks, bp)))
440                         goto out;
441                 offset = xlog_align(log, start_blk, num_blks, bp);
442                 offset += ((num_blks - 1) << BBSHIFT);
443         }
444
445         for (i = (*last_blk) - 1; i >= 0; i--) {
446                 if (i < start_blk) {
447                         /* valid log record not found */
448                         xlog_warn(
449                 "XFS: Log inconsistent (didn't find previous header)");
450                         ASSERT(0);
451                         error = XFS_ERROR(EIO);
452                         goto out;
453                 }
454
455                 if (smallmem) {
456                         if ((error = xlog_bread(log, i, 1, bp)))
457                                 goto out;
458                         offset = xlog_align(log, i, 1, bp);
459                 }
460
461                 head = (xlog_rec_header_t *)offset;
462
463                 if (XLOG_HEADER_MAGIC_NUM == be32_to_cpu(head->h_magicno))
464                         break;
465
466                 if (!smallmem)
467                         offset -= BBSIZE;
468         }
469
470         /*
471          * We hit the beginning of the physical log & still no header.  Return
472          * to caller.  If caller can handle a return of -1, then this routine
473          * will be called again for the end of the physical log.
474          */
475         if (i == -1) {
476                 error = -1;
477                 goto out;
478         }
479
480         /*
481          * We have the final block of the good log (the first block
482          * of the log record _before_ the head. So we check the uuid.
483          */
484         if ((error = xlog_header_check_mount(log->l_mp, head)))
485                 goto out;
486
487         /*
488          * We may have found a log record header before we expected one.
489          * last_blk will be the 1st block # with a given cycle #.  We may end
490          * up reading an entire log record.  In this case, we don't want to
491          * reset last_blk.  Only when last_blk points in the middle of a log
492          * record do we update last_blk.
493          */
494         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
495                 uint    h_size = be32_to_cpu(head->h_size);
496
497                 xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
498                 if (h_size % XLOG_HEADER_CYCLE_SIZE)
499                         xhdrs++;
500         } else {
501                 xhdrs = 1;
502         }
503
504         if (*last_blk - i + extra_bblks !=
505             BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
506                 *last_blk = i;
507
508 out:
509         xlog_put_bp(bp);
510         return error;
511 }
512
513 /*
514  * Head is defined to be the point of the log where the next log write
515  * write could go.  This means that incomplete LR writes at the end are
516  * eliminated when calculating the head.  We aren't guaranteed that previous
517  * LR have complete transactions.  We only know that a cycle number of
518  * current cycle number -1 won't be present in the log if we start writing
519  * from our current block number.
520  *
521  * last_blk contains the block number of the first block with a given
522  * cycle number.
523  *
524  * Return: zero if normal, non-zero if error.
525  */
526 STATIC int
527 xlog_find_head(
528         xlog_t          *log,
529         xfs_daddr_t     *return_head_blk)
530 {
531         xfs_buf_t       *bp;
532         xfs_caddr_t     offset;
533         xfs_daddr_t     new_blk, first_blk, start_blk, last_blk, head_blk;
534         int             num_scan_bblks;
535         uint            first_half_cycle, last_half_cycle;
536         uint            stop_on_cycle;
537         int             error, log_bbnum = log->l_logBBsize;
538
539         /* Is the end of the log device zeroed? */
540         if ((error = xlog_find_zeroed(log, &first_blk)) == -1) {
541                 *return_head_blk = first_blk;
542
543                 /* Is the whole lot zeroed? */
544                 if (!first_blk) {
545                         /* Linux XFS shouldn't generate totally zeroed logs -
546                          * mkfs etc write a dummy unmount record to a fresh
547                          * log so we can store the uuid in there
548                          */
549                         xlog_warn("XFS: totally zeroed log");
550                 }
551
552                 return 0;
553         } else if (error) {
554                 xlog_warn("XFS: empty log check failed");
555                 return error;
556         }
557
558         first_blk = 0;                  /* get cycle # of 1st block */
559         bp = xlog_get_bp(log, 1);
560         if (!bp)
561                 return ENOMEM;
562         if ((error = xlog_bread(log, 0, 1, bp)))
563                 goto bp_err;
564         offset = xlog_align(log, 0, 1, bp);
565         first_half_cycle = xlog_get_cycle(offset);
566
567         last_blk = head_blk = log_bbnum - 1;    /* get cycle # of last block */
568         if ((error = xlog_bread(log, last_blk, 1, bp)))
569                 goto bp_err;
570         offset = xlog_align(log, last_blk, 1, bp);
571         last_half_cycle = xlog_get_cycle(offset);
572         ASSERT(last_half_cycle != 0);
573
574         /*
575          * If the 1st half cycle number is equal to the last half cycle number,
576          * then the entire log is stamped with the same cycle number.  In this
577          * case, head_blk can't be set to zero (which makes sense).  The below
578          * math doesn't work out properly with head_blk equal to zero.  Instead,
579          * we set it to log_bbnum which is an invalid block number, but this
580          * value makes the math correct.  If head_blk doesn't changed through
581          * all the tests below, *head_blk is set to zero at the very end rather
582          * than log_bbnum.  In a sense, log_bbnum and zero are the same block
583          * in a circular file.
584          */
585         if (first_half_cycle == last_half_cycle) {
586                 /*
587                  * In this case we believe that the entire log should have
588                  * cycle number last_half_cycle.  We need to scan backwards
589                  * from the end verifying that there are no holes still
590                  * containing last_half_cycle - 1.  If we find such a hole,
591                  * then the start of that hole will be the new head.  The
592                  * simple case looks like
593                  *        x | x ... | x - 1 | x
594                  * Another case that fits this picture would be
595                  *        x | x + 1 | x ... | x
596                  * In this case the head really is somewhere at the end of the
597                  * log, as one of the latest writes at the beginning was
598                  * incomplete.
599                  * One more case is
600                  *        x | x + 1 | x ... | x - 1 | x
601                  * This is really the combination of the above two cases, and
602                  * the head has to end up at the start of the x-1 hole at the
603                  * end of the log.
604                  *
605                  * In the 256k log case, we will read from the beginning to the
606                  * end of the log and search for cycle numbers equal to x-1.
607                  * We don't worry about the x+1 blocks that we encounter,
608                  * because we know that they cannot be the head since the log
609                  * started with x.
610                  */
611                 head_blk = log_bbnum;
612                 stop_on_cycle = last_half_cycle - 1;
613         } else {
614                 /*
615                  * In this case we want to find the first block with cycle
616                  * number matching last_half_cycle.  We expect the log to be
617                  * some variation on
618                  *        x + 1 ... | x ...
619                  * The first block with cycle number x (last_half_cycle) will
620                  * be where the new head belongs.  First we do a binary search
621                  * for the first occurrence of last_half_cycle.  The binary
622                  * search may not be totally accurate, so then we scan back
623                  * from there looking for occurrences of last_half_cycle before
624                  * us.  If that backwards scan wraps around the beginning of
625                  * the log, then we look for occurrences of last_half_cycle - 1
626                  * at the end of the log.  The cases we're looking for look
627                  * like
628                  *        x + 1 ... | x | x + 1 | x ...
629                  *                               ^ binary search stopped here
630                  * or
631                  *        x + 1 ... | x ... | x - 1 | x
632                  *        <---------> less than scan distance
633                  */
634                 stop_on_cycle = last_half_cycle;
635                 if ((error = xlog_find_cycle_start(log, bp, first_blk,
636                                                 &head_blk, last_half_cycle)))
637                         goto bp_err;
638         }
639
640         /*
641          * Now validate the answer.  Scan back some number of maximum possible
642          * blocks and make sure each one has the expected cycle number.  The
643          * maximum is determined by the total possible amount of buffering
644          * in the in-core log.  The following number can be made tighter if
645          * we actually look at the block size of the filesystem.
646          */
647         num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
648         if (head_blk >= num_scan_bblks) {
649                 /*
650                  * We are guaranteed that the entire check can be performed
651                  * in one buffer.
652                  */
653                 start_blk = head_blk - num_scan_bblks;
654                 if ((error = xlog_find_verify_cycle(log,
655                                                 start_blk, num_scan_bblks,
656                                                 stop_on_cycle, &new_blk)))
657                         goto bp_err;
658                 if (new_blk != -1)
659                         head_blk = new_blk;
660         } else {                /* need to read 2 parts of log */
661                 /*
662                  * We are going to scan backwards in the log in two parts.
663                  * First we scan the physical end of the log.  In this part
664                  * of the log, we are looking for blocks with cycle number
665                  * last_half_cycle - 1.
666                  * If we find one, then we know that the log starts there, as
667                  * we've found a hole that didn't get written in going around
668                  * the end of the physical log.  The simple case for this is
669                  *        x + 1 ... | x ... | x - 1 | x
670                  *        <---------> less than scan distance
671                  * If all of the blocks at the end of the log have cycle number
672                  * last_half_cycle, then we check the blocks at the start of
673                  * the log looking for occurrences of last_half_cycle.  If we
674                  * find one, then our current estimate for the location of the
675                  * first occurrence of last_half_cycle is wrong and we move
676                  * back to the hole we've found.  This case looks like
677                  *        x + 1 ... | x | x + 1 | x ...
678                  *                               ^ binary search stopped here
679                  * Another case we need to handle that only occurs in 256k
680                  * logs is
681                  *        x + 1 ... | x ... | x+1 | x ...
682                  *                   ^ binary search stops here
683                  * In a 256k log, the scan at the end of the log will see the
684                  * x + 1 blocks.  We need to skip past those since that is
685                  * certainly not the head of the log.  By searching for
686                  * last_half_cycle-1 we accomplish that.
687                  */
688                 start_blk = log_bbnum - num_scan_bblks + head_blk;
689                 ASSERT(head_blk <= INT_MAX &&
690                         (xfs_daddr_t) num_scan_bblks - head_blk >= 0);
691                 if ((error = xlog_find_verify_cycle(log, start_blk,
692                                         num_scan_bblks - (int)head_blk,
693                                         (stop_on_cycle - 1), &new_blk)))
694                         goto bp_err;
695                 if (new_blk != -1) {
696                         head_blk = new_blk;
697                         goto bad_blk;
698                 }
699
700                 /*
701                  * Scan beginning of log now.  The last part of the physical
702                  * log is good.  This scan needs to verify that it doesn't find
703                  * the last_half_cycle.
704                  */
705                 start_blk = 0;
706                 ASSERT(head_blk <= INT_MAX);
707                 if ((error = xlog_find_verify_cycle(log,
708                                         start_blk, (int)head_blk,
709                                         stop_on_cycle, &new_blk)))
710                         goto bp_err;
711                 if (new_blk != -1)
712                         head_blk = new_blk;
713         }
714
715  bad_blk:
716         /*
717          * Now we need to make sure head_blk is not pointing to a block in
718          * the middle of a log record.
719          */
720         num_scan_bblks = XLOG_REC_SHIFT(log);
721         if (head_blk >= num_scan_bblks) {
722                 start_blk = head_blk - num_scan_bblks; /* don't read head_blk */
723
724                 /* start ptr at last block ptr before head_blk */
725                 if ((error = xlog_find_verify_log_record(log, start_blk,
726                                                         &head_blk, 0)) == -1) {
727                         error = XFS_ERROR(EIO);
728                         goto bp_err;
729                 } else if (error)
730                         goto bp_err;
731         } else {
732                 start_blk = 0;
733                 ASSERT(head_blk <= INT_MAX);
734                 if ((error = xlog_find_verify_log_record(log, start_blk,
735                                                         &head_blk, 0)) == -1) {
736                         /* We hit the beginning of the log during our search */
737                         start_blk = log_bbnum - num_scan_bblks + head_blk;
738                         new_blk = log_bbnum;
739                         ASSERT(start_blk <= INT_MAX &&
740                                 (xfs_daddr_t) log_bbnum-start_blk >= 0);
741                         ASSERT(head_blk <= INT_MAX);
742                         if ((error = xlog_find_verify_log_record(log,
743                                                         start_blk, &new_blk,
744                                                         (int)head_blk)) == -1) {
745                                 error = XFS_ERROR(EIO);
746                                 goto bp_err;
747                         } else if (error)
748                                 goto bp_err;
749                         if (new_blk != log_bbnum)
750                                 head_blk = new_blk;
751                 } else if (error)
752                         goto bp_err;
753         }
754
755         xlog_put_bp(bp);
756         if (head_blk == log_bbnum)
757                 *return_head_blk = 0;
758         else
759                 *return_head_blk = head_blk;
760         /*
761          * When returning here, we have a good block number.  Bad block
762          * means that during a previous crash, we didn't have a clean break
763          * from cycle number N to cycle number N-1.  In this case, we need
764          * to find the first block with cycle number N-1.
765          */
766         return 0;
767
768  bp_err:
769         xlog_put_bp(bp);
770
771         if (error)
772             xlog_warn("XFS: failed to find log head");
773         return error;
774 }
775
776 /*
777  * Find the sync block number or the tail of the log.
778  *
779  * This will be the block number of the last record to have its
780  * associated buffers synced to disk.  Every log record header has
781  * a sync lsn embedded in it.  LSNs hold block numbers, so it is easy
782  * to get a sync block number.  The only concern is to figure out which
783  * log record header to believe.
784  *
785  * The following algorithm uses the log record header with the largest
786  * lsn.  The entire log record does not need to be valid.  We only care
787  * that the header is valid.
788  *
789  * We could speed up search by using current head_blk buffer, but it is not
790  * available.
791  */
792 int
793 xlog_find_tail(
794         xlog_t                  *log,
795         xfs_daddr_t             *head_blk,
796         xfs_daddr_t             *tail_blk)
797 {
798         xlog_rec_header_t       *rhead;
799         xlog_op_header_t        *op_head;
800         xfs_caddr_t             offset = NULL;
801         xfs_buf_t               *bp;
802         int                     error, i, found;
803         xfs_daddr_t             umount_data_blk;
804         xfs_daddr_t             after_umount_blk;
805         xfs_lsn_t               tail_lsn;
806         int                     hblks;
807
808         found = 0;
809
810         /*
811          * Find previous log record
812          */
813         if ((error = xlog_find_head(log, head_blk)))
814                 return error;
815
816         bp = xlog_get_bp(log, 1);
817         if (!bp)
818                 return ENOMEM;
819         if (*head_blk == 0) {                           /* special case */
820                 if ((error = xlog_bread(log, 0, 1, bp)))
821                         goto bread_err;
822                 offset = xlog_align(log, 0, 1, bp);
823                 if (xlog_get_cycle(offset) == 0) {
824                         *tail_blk = 0;
825                         /* leave all other log inited values alone */
826                         goto exit;
827                 }
828         }
829
830         /*
831          * Search backwards looking for log record header block
832          */
833         ASSERT(*head_blk < INT_MAX);
834         for (i = (int)(*head_blk) - 1; i >= 0; i--) {
835                 if ((error = xlog_bread(log, i, 1, bp)))
836                         goto bread_err;
837                 offset = xlog_align(log, i, 1, bp);
838                 if (XLOG_HEADER_MAGIC_NUM == be32_to_cpu(*(__be32 *)offset)) {
839                         found = 1;
840                         break;
841                 }
842         }
843         /*
844          * If we haven't found the log record header block, start looking
845          * again from the end of the physical log.  XXXmiken: There should be
846          * a check here to make sure we didn't search more than N blocks in
847          * the previous code.
848          */
849         if (!found) {
850                 for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {
851                         if ((error = xlog_bread(log, i, 1, bp)))
852                                 goto bread_err;
853                         offset = xlog_align(log, i, 1, bp);
854                         if (XLOG_HEADER_MAGIC_NUM ==
855                             be32_to_cpu(*(__be32 *)offset)) {
856                                 found = 2;
857                                 break;
858                         }
859                 }
860         }
861         if (!found) {
862                 xlog_warn("XFS: xlog_find_tail: couldn't find sync record");
863                 ASSERT(0);
864                 return XFS_ERROR(EIO);
865         }
866
867         /* find blk_no of tail of log */
868         rhead = (xlog_rec_header_t *)offset;
869         *tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn));
870
871         /*
872          * Reset log values according to the state of the log when we
873          * crashed.  In the case where head_blk == 0, we bump curr_cycle
874          * one because the next write starts a new cycle rather than
875          * continuing the cycle of the last good log record.  At this
876          * point we have guaranteed that all partial log records have been
877          * accounted for.  Therefore, we know that the last good log record
878          * written was complete and ended exactly on the end boundary
879          * of the physical log.
880          */
881         log->l_prev_block = i;
882         log->l_curr_block = (int)*head_blk;
883         log->l_curr_cycle = be32_to_cpu(rhead->h_cycle);
884         if (found == 2)
885                 log->l_curr_cycle++;
886         log->l_tail_lsn = be64_to_cpu(rhead->h_tail_lsn);
887         log->l_last_sync_lsn = be64_to_cpu(rhead->h_lsn);
888         log->l_grant_reserve_cycle = log->l_curr_cycle;
889         log->l_grant_reserve_bytes = BBTOB(log->l_curr_block);
890         log->l_grant_write_cycle = log->l_curr_cycle;
891         log->l_grant_write_bytes = BBTOB(log->l_curr_block);
892
893         /*
894          * Look for unmount record.  If we find it, then we know there
895          * was a clean unmount.  Since 'i' could be the last block in
896          * the physical log, we convert to a log block before comparing
897          * to the head_blk.
898          *
899          * Save the current tail lsn to use to pass to
900          * xlog_clear_stale_blocks() below.  We won't want to clear the
901          * unmount record if there is one, so we pass the lsn of the
902          * unmount record rather than the block after it.
903          */
904         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
905                 int     h_size = be32_to_cpu(rhead->h_size);
906                 int     h_version = be32_to_cpu(rhead->h_version);
907
908                 if ((h_version & XLOG_VERSION_2) &&
909                     (h_size > XLOG_HEADER_CYCLE_SIZE)) {
910                         hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
911                         if (h_size % XLOG_HEADER_CYCLE_SIZE)
912                                 hblks++;
913                 } else {
914                         hblks = 1;
915                 }
916         } else {
917                 hblks = 1;
918         }
919         after_umount_blk = (i + hblks + (int)
920                 BTOBB(be32_to_cpu(rhead->h_len))) % log->l_logBBsize;
921         tail_lsn = log->l_tail_lsn;
922         if (*head_blk == after_umount_blk &&
923             be32_to_cpu(rhead->h_num_logops) == 1) {
924                 umount_data_blk = (i + hblks) % log->l_logBBsize;
925                 if ((error = xlog_bread(log, umount_data_blk, 1, bp))) {
926                         goto bread_err;
927                 }
928                 offset = xlog_align(log, umount_data_blk, 1, bp);
929                 op_head = (xlog_op_header_t *)offset;
930                 if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
931                         /*
932                          * Set tail and last sync so that newly written
933                          * log records will point recovery to after the
934                          * current unmount record.
935                          */
936                         log->l_tail_lsn =
937                                 xlog_assign_lsn(log->l_curr_cycle,
938                                                 after_umount_blk);
939                         log->l_last_sync_lsn =
940                                 xlog_assign_lsn(log->l_curr_cycle,
941                                                 after_umount_blk);
942                         *tail_blk = after_umount_blk;
943
944                         /*
945                          * Note that the unmount was clean. If the unmount
946                          * was not clean, we need to know this to rebuild the
947                          * superblock counters from the perag headers if we
948                          * have a filesystem using non-persistent counters.
949                          */
950                         log->l_mp->m_flags |= XFS_MOUNT_WAS_CLEAN;
951                 }
952         }
953
954         /*
955          * Make sure that there are no blocks in front of the head
956          * with the same cycle number as the head.  This can happen
957          * because we allow multiple outstanding log writes concurrently,
958          * and the later writes might make it out before earlier ones.
959          *
960          * We use the lsn from before modifying it so that we'll never
961          * overwrite the unmount record after a clean unmount.
962          *
963          * Do this only if we are going to recover the filesystem
964          *
965          * NOTE: This used to say "if (!readonly)"
966          * However on Linux, we can & do recover a read-only filesystem.
967          * We only skip recovery if NORECOVERY is specified on mount,
968          * in which case we would not be here.
969          *
970          * But... if the -device- itself is readonly, just skip this.
971          * We can't recover this device anyway, so it won't matter.
972          */
973         if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp)) {
974                 error = xlog_clear_stale_blocks(log, tail_lsn);
975         }
976
977 bread_err:
978 exit:
979         xlog_put_bp(bp);
980
981         if (error)
982                 xlog_warn("XFS: failed to locate log tail");
983         return error;
984 }
985
986 /*
987  * Is the log zeroed at all?
988  *
989  * The last binary search should be changed to perform an X block read
990  * once X becomes small enough.  You can then search linearly through
991  * the X blocks.  This will cut down on the number of reads we need to do.
992  *
993  * If the log is partially zeroed, this routine will pass back the blkno
994  * of the first block with cycle number 0.  It won't have a complete LR
995  * preceding it.
996  *
997  * Return:
998  *      0  => the log is completely written to
999  *      -1 => use *blk_no as the first block of the log
1000  *      >0 => error has occurred
1001  */
1002 STATIC int
1003 xlog_find_zeroed(
1004         xlog_t          *log,
1005         xfs_daddr_t     *blk_no)
1006 {
1007         xfs_buf_t       *bp;
1008         xfs_caddr_t     offset;
1009         uint            first_cycle, last_cycle;
1010         xfs_daddr_t     new_blk, last_blk, start_blk;
1011         xfs_daddr_t     num_scan_bblks;
1012         int             error, log_bbnum = log->l_logBBsize;
1013
1014         *blk_no = 0;
1015
1016         /* check totally zeroed log */
1017         bp = xlog_get_bp(log, 1);
1018         if (!bp)
1019                 return ENOMEM;
1020         if ((error = xlog_bread(log, 0, 1, bp)))
1021                 goto bp_err;
1022         offset = xlog_align(log, 0, 1, bp);
1023         first_cycle = xlog_get_cycle(offset);
1024         if (first_cycle == 0) {         /* completely zeroed log */
1025                 *blk_no = 0;
1026                 xlog_put_bp(bp);
1027                 return -1;
1028         }
1029
1030         /* check partially zeroed log */
1031         if ((error = xlog_bread(log, log_bbnum-1, 1, bp)))
1032                 goto bp_err;
1033         offset = xlog_align(log, log_bbnum-1, 1, bp);
1034         last_cycle = xlog_get_cycle(offset);
1035         if (last_cycle != 0) {          /* log completely written to */
1036                 xlog_put_bp(bp);
1037                 return 0;
1038         } else if (first_cycle != 1) {
1039                 /*
1040                  * If the cycle of the last block is zero, the cycle of
1041                  * the first block must be 1. If it's not, maybe we're
1042                  * not looking at a log... Bail out.
1043                  */
1044                 xlog_warn("XFS: Log inconsistent or not a log (last==0, first!=1)");
1045                 return XFS_ERROR(EINVAL);
1046         }
1047
1048         /* we have a partially zeroed log */
1049         last_blk = log_bbnum-1;
1050         if ((error = xlog_find_cycle_start(log, bp, 0, &last_blk, 0)))
1051                 goto bp_err;
1052
1053         /*
1054          * Validate the answer.  Because there is no way to guarantee that
1055          * the entire log is made up of log records which are the same size,
1056          * we scan over the defined maximum blocks.  At this point, the maximum
1057          * is not chosen to mean anything special.   XXXmiken
1058          */
1059         num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
1060         ASSERT(num_scan_bblks <= INT_MAX);
1061
1062         if (last_blk < num_scan_bblks)
1063                 num_scan_bblks = last_blk;
1064         start_blk = last_blk - num_scan_bblks;
1065
1066         /*
1067          * We search for any instances of cycle number 0 that occur before
1068          * our current estimate of the head.  What we're trying to detect is
1069          *        1 ... | 0 | 1 | 0...
1070          *                       ^ binary search ends here
1071          */
1072         if ((error = xlog_find_verify_cycle(log, start_blk,
1073                                          (int)num_scan_bblks, 0, &new_blk)))
1074                 goto bp_err;
1075         if (new_blk != -1)
1076                 last_blk = new_blk;
1077
1078         /*
1079          * Potentially backup over partial log record write.  We don't need
1080          * to search the end of the log because we know it is zero.
1081          */
1082         if ((error = xlog_find_verify_log_record(log, start_blk,
1083                                 &last_blk, 0)) == -1) {
1084             error = XFS_ERROR(EIO);
1085             goto bp_err;
1086         } else if (error)
1087             goto bp_err;
1088
1089         *blk_no = last_blk;
1090 bp_err:
1091         xlog_put_bp(bp);
1092         if (error)
1093                 return error;
1094         return -1;
1095 }
1096
1097 /*
1098  * These are simple subroutines used by xlog_clear_stale_blocks() below
1099  * to initialize a buffer full of empty log record headers and write
1100  * them into the log.
1101  */
1102 STATIC void
1103 xlog_add_record(
1104         xlog_t                  *log,
1105         xfs_caddr_t             buf,
1106         int                     cycle,
1107         int                     block,
1108         int                     tail_cycle,
1109         int                     tail_block)
1110 {
1111         xlog_rec_header_t       *recp = (xlog_rec_header_t *)buf;
1112
1113         memset(buf, 0, BBSIZE);
1114         recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
1115         recp->h_cycle = cpu_to_be32(cycle);
1116         recp->h_version = cpu_to_be32(
1117                         xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
1118         recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block));
1119         recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block));
1120         recp->h_fmt = cpu_to_be32(XLOG_FMT);
1121         memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
1122 }
1123
1124 STATIC int
1125 xlog_write_log_records(
1126         xlog_t          *log,
1127         int             cycle,
1128         int             start_block,
1129         int             blocks,
1130         int             tail_cycle,
1131         int             tail_block)
1132 {
1133         xfs_caddr_t     offset;
1134         xfs_buf_t       *bp;
1135         int             balign, ealign;
1136         int             sectbb = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, 1);
1137         int             end_block = start_block + blocks;
1138         int             bufblks;
1139         int             error = 0;
1140         int             i, j = 0;
1141
1142         bufblks = 1 << ffs(blocks);
1143         while (!(bp = xlog_get_bp(log, bufblks))) {
1144                 bufblks >>= 1;
1145                 if (bufblks <= log->l_sectbb_log)
1146                         return ENOMEM;
1147         }
1148
1149         /* We may need to do a read at the start to fill in part of
1150          * the buffer in the starting sector not covered by the first
1151          * write below.
1152          */
1153         balign = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, start_block);
1154         if (balign != start_block) {
1155                 if ((error = xlog_bread(log, start_block, 1, bp))) {
1156                         xlog_put_bp(bp);
1157                         return error;
1158                 }
1159                 j = start_block - balign;
1160         }
1161
1162         for (i = start_block; i < end_block; i += bufblks) {
1163                 int             bcount, endcount;
1164
1165                 bcount = min(bufblks, end_block - start_block);
1166                 endcount = bcount - j;
1167
1168                 /* We may need to do a read at the end to fill in part of
1169                  * the buffer in the final sector not covered by the write.
1170                  * If this is the same sector as the above read, skip it.
1171                  */
1172                 ealign = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, end_block);
1173                 if (j == 0 && (start_block + endcount > ealign)) {
1174                         offset = XFS_BUF_PTR(bp);
1175                         balign = BBTOB(ealign - start_block);
1176                         error = XFS_BUF_SET_PTR(bp, offset + balign,
1177                                                 BBTOB(sectbb));
1178                         if (!error)
1179                                 error = xlog_bread(log, ealign, sectbb, bp);
1180                         if (!error)
1181                                 error = XFS_BUF_SET_PTR(bp, offset, bufblks);
1182                         if (error)
1183                                 break;
1184                 }
1185
1186                 offset = xlog_align(log, start_block, endcount, bp);
1187                 for (; j < endcount; j++) {
1188                         xlog_add_record(log, offset, cycle, i+j,
1189                                         tail_cycle, tail_block);
1190                         offset += BBSIZE;
1191                 }
1192                 error = xlog_bwrite(log, start_block, endcount, bp);
1193                 if (error)
1194                         break;
1195                 start_block += endcount;
1196                 j = 0;
1197         }
1198         xlog_put_bp(bp);
1199         return error;
1200 }
1201
1202 /*
1203  * This routine is called to blow away any incomplete log writes out
1204  * in front of the log head.  We do this so that we won't become confused
1205  * if we come up, write only a little bit more, and then crash again.
1206  * If we leave the partial log records out there, this situation could
1207  * cause us to think those partial writes are valid blocks since they
1208  * have the current cycle number.  We get rid of them by overwriting them
1209  * with empty log records with the old cycle number rather than the
1210  * current one.
1211  *
1212  * The tail lsn is passed in rather than taken from
1213  * the log so that we will not write over the unmount record after a
1214  * clean unmount in a 512 block log.  Doing so would leave the log without
1215  * any valid log records in it until a new one was written.  If we crashed
1216  * during that time we would not be able to recover.
1217  */
1218 STATIC int
1219 xlog_clear_stale_blocks(
1220         xlog_t          *log,
1221         xfs_lsn_t       tail_lsn)
1222 {
1223         int             tail_cycle, head_cycle;
1224         int             tail_block, head_block;
1225         int             tail_distance, max_distance;
1226         int             distance;
1227         int             error;
1228
1229         tail_cycle = CYCLE_LSN(tail_lsn);
1230         tail_block = BLOCK_LSN(tail_lsn);
1231         head_cycle = log->l_curr_cycle;
1232         head_block = log->l_curr_block;
1233
1234         /*
1235          * Figure out the distance between the new head of the log
1236          * and the tail.  We want to write over any blocks beyond the
1237          * head that we may have written just before the crash, but
1238          * we don't want to overwrite the tail of the log.
1239          */
1240         if (head_cycle == tail_cycle) {
1241                 /*
1242                  * The tail is behind the head in the physical log,
1243                  * so the distance from the head to the tail is the
1244                  * distance from the head to the end of the log plus
1245                  * the distance from the beginning of the log to the
1246                  * tail.
1247                  */
1248                 if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
1249                         XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
1250                                          XFS_ERRLEVEL_LOW, log->l_mp);
1251                         return XFS_ERROR(EFSCORRUPTED);
1252                 }
1253                 tail_distance = tail_block + (log->l_logBBsize - head_block);
1254         } else {
1255                 /*
1256                  * The head is behind the tail in the physical log,
1257                  * so the distance from the head to the tail is just
1258                  * the tail block minus the head block.
1259                  */
1260                 if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
1261                         XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
1262                                          XFS_ERRLEVEL_LOW, log->l_mp);
1263                         return XFS_ERROR(EFSCORRUPTED);
1264                 }
1265                 tail_distance = tail_block - head_block;
1266         }
1267
1268         /*
1269          * If the head is right up against the tail, we can't clear
1270          * anything.
1271          */
1272         if (tail_distance <= 0) {
1273                 ASSERT(tail_distance == 0);
1274                 return 0;
1275         }
1276
1277         max_distance = XLOG_TOTAL_REC_SHIFT(log);
1278         /*
1279          * Take the smaller of the maximum amount of outstanding I/O
1280          * we could have and the distance to the tail to clear out.
1281          * We take the smaller so that we don't overwrite the tail and
1282          * we don't waste all day writing from the head to the tail
1283          * for no reason.
1284          */
1285         max_distance = MIN(max_distance, tail_distance);
1286
1287         if ((head_block + max_distance) <= log->l_logBBsize) {
1288                 /*
1289                  * We can stomp all the blocks we need to without
1290                  * wrapping around the end of the log.  Just do it
1291                  * in a single write.  Use the cycle number of the
1292                  * current cycle minus one so that the log will look like:
1293                  *     n ... | n - 1 ...
1294                  */
1295                 error = xlog_write_log_records(log, (head_cycle - 1),
1296                                 head_block, max_distance, tail_cycle,
1297                                 tail_block);
1298                 if (error)
1299                         return error;
1300         } else {
1301                 /*
1302                  * We need to wrap around the end of the physical log in
1303                  * order to clear all the blocks.  Do it in two separate
1304                  * I/Os.  The first write should be from the head to the
1305                  * end of the physical log, and it should use the current
1306                  * cycle number minus one just like above.
1307                  */
1308                 distance = log->l_logBBsize - head_block;
1309                 error = xlog_write_log_records(log, (head_cycle - 1),
1310                                 head_block, distance, tail_cycle,
1311                                 tail_block);
1312
1313                 if (error)
1314                         return error;
1315
1316                 /*
1317                  * Now write the blocks at the start of the physical log.
1318                  * This writes the remainder of the blocks we want to clear.
1319                  * It uses the current cycle number since we're now on the
1320                  * same cycle as the head so that we get:
1321                  *    n ... n ... | n - 1 ...
1322                  *    ^^^^^ blocks we're writing
1323                  */
1324                 distance = max_distance - (log->l_logBBsize - head_block);
1325                 error = xlog_write_log_records(log, head_cycle, 0, distance,
1326                                 tail_cycle, tail_block);
1327                 if (error)
1328                         return error;
1329         }
1330
1331         return 0;
1332 }
1333
1334 /******************************************************************************
1335  *
1336  *              Log recover routines
1337  *
1338  ******************************************************************************
1339  */
1340
1341 STATIC xlog_recover_t *
1342 xlog_recover_find_tid(
1343         xlog_recover_t          *q,
1344         xlog_tid_t              tid)
1345 {
1346         xlog_recover_t          *p = q;
1347
1348         while (p != NULL) {
1349                 if (p->r_log_tid == tid)
1350                     break;
1351                 p = p->r_next;
1352         }
1353         return p;
1354 }
1355
1356 STATIC void
1357 xlog_recover_put_hashq(
1358         xlog_recover_t          **q,
1359         xlog_recover_t          *trans)
1360 {
1361         trans->r_next = *q;
1362         *q = trans;
1363 }
1364
1365 STATIC void
1366 xlog_recover_add_item(
1367         xlog_recover_item_t     **itemq)
1368 {
1369         xlog_recover_item_t     *item;
1370
1371         item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
1372         xlog_recover_insert_item_backq(itemq, item);
1373 }
1374
1375 STATIC int
1376 xlog_recover_add_to_cont_trans(
1377         xlog_recover_t          *trans,
1378         xfs_caddr_t             dp,
1379         int                     len)
1380 {
1381         xlog_recover_item_t     *item;
1382         xfs_caddr_t             ptr, old_ptr;
1383         int                     old_len;
1384
1385         item = trans->r_itemq;
1386         if (item == NULL) {
1387                 /* finish copying rest of trans header */
1388                 xlog_recover_add_item(&trans->r_itemq);
1389                 ptr = (xfs_caddr_t) &trans->r_theader +
1390                                 sizeof(xfs_trans_header_t) - len;
1391                 memcpy(ptr, dp, len); /* d, s, l */
1392                 return 0;
1393         }
1394         item = item->ri_prev;
1395
1396         old_ptr = item->ri_buf[item->ri_cnt-1].i_addr;
1397         old_len = item->ri_buf[item->ri_cnt-1].i_len;
1398
1399         ptr = kmem_realloc(old_ptr, len+old_len, old_len, 0u);
1400         memcpy(&ptr[old_len], dp, len); /* d, s, l */
1401         item->ri_buf[item->ri_cnt-1].i_len += len;
1402         item->ri_buf[item->ri_cnt-1].i_addr = ptr;
1403         return 0;
1404 }
1405
1406 /*
1407  * The next region to add is the start of a new region.  It could be
1408  * a whole region or it could be the first part of a new region.  Because
1409  * of this, the assumption here is that the type and size fields of all
1410  * format structures fit into the first 32 bits of the structure.
1411  *
1412  * This works because all regions must be 32 bit aligned.  Therefore, we
1413  * either have both fields or we have neither field.  In the case we have
1414  * neither field, the data part of the region is zero length.  We only have
1415  * a log_op_header and can throw away the header since a new one will appear
1416  * later.  If we have at least 4 bytes, then we can determine how many regions
1417  * will appear in the current log item.
1418  */
1419 STATIC int
1420 xlog_recover_add_to_trans(
1421         xlog_recover_t          *trans,
1422         xfs_caddr_t             dp,
1423         int                     len)
1424 {
1425         xfs_inode_log_format_t  *in_f;                  /* any will do */
1426         xlog_recover_item_t     *item;
1427         xfs_caddr_t             ptr;
1428
1429         if (!len)
1430                 return 0;
1431         item = trans->r_itemq;
1432         if (item == NULL) {
1433                 /* we need to catch log corruptions here */
1434                 if (*(uint *)dp != XFS_TRANS_HEADER_MAGIC) {
1435                         xlog_warn("XFS: xlog_recover_add_to_trans: "
1436                                   "bad header magic number");
1437                         ASSERT(0);
1438                         return XFS_ERROR(EIO);
1439                 }
1440                 if (len == sizeof(xfs_trans_header_t))
1441                         xlog_recover_add_item(&trans->r_itemq);
1442                 memcpy(&trans->r_theader, dp, len); /* d, s, l */
1443                 return 0;
1444         }
1445
1446         ptr = kmem_alloc(len, KM_SLEEP);
1447         memcpy(ptr, dp, len);
1448         in_f = (xfs_inode_log_format_t *)ptr;
1449
1450         if (item->ri_prev->ri_total != 0 &&
1451              item->ri_prev->ri_total == item->ri_prev->ri_cnt) {
1452                 xlog_recover_add_item(&trans->r_itemq);
1453         }
1454         item = trans->r_itemq;
1455         item = item->ri_prev;
1456
1457         if (item->ri_total == 0) {              /* first region to be added */
1458                 item->ri_total  = in_f->ilf_size;
1459                 ASSERT(item->ri_total <= XLOG_MAX_REGIONS_IN_ITEM);
1460                 item->ri_buf = kmem_zalloc((item->ri_total *
1461                                             sizeof(xfs_log_iovec_t)), KM_SLEEP);
1462         }
1463         ASSERT(item->ri_total > item->ri_cnt);
1464         /* Description region is ri_buf[0] */
1465         item->ri_buf[item->ri_cnt].i_addr = ptr;
1466         item->ri_buf[item->ri_cnt].i_len  = len;
1467         item->ri_cnt++;
1468         return 0;
1469 }
1470
1471 STATIC void
1472 xlog_recover_new_tid(
1473         xlog_recover_t          **q,
1474         xlog_tid_t              tid,
1475         xfs_lsn_t               lsn)
1476 {
1477         xlog_recover_t          *trans;
1478
1479         trans = kmem_zalloc(sizeof(xlog_recover_t), KM_SLEEP);
1480         trans->r_log_tid   = tid;
1481         trans->r_lsn       = lsn;
1482         xlog_recover_put_hashq(q, trans);
1483 }
1484
1485 STATIC int
1486 xlog_recover_unlink_tid(
1487         xlog_recover_t          **q,
1488         xlog_recover_t          *trans)
1489 {
1490         xlog_recover_t          *tp;
1491         int                     found = 0;
1492
1493         ASSERT(trans != NULL);
1494         if (trans == *q) {
1495                 *q = (*q)->r_next;
1496         } else {
1497                 tp = *q;
1498                 while (tp) {
1499                         if (tp->r_next == trans) {
1500                                 found = 1;
1501                                 break;
1502                         }
1503                         tp = tp->r_next;
1504                 }
1505                 if (!found) {
1506                         xlog_warn(
1507                              "XFS: xlog_recover_unlink_tid: trans not found");
1508                         ASSERT(0);
1509                         return XFS_ERROR(EIO);
1510                 }
1511                 tp->r_next = tp->r_next->r_next;
1512         }
1513         return 0;
1514 }
1515
1516 STATIC void
1517 xlog_recover_insert_item_backq(
1518         xlog_recover_item_t     **q,
1519         xlog_recover_item_t     *item)
1520 {
1521         if (*q == NULL) {
1522                 item->ri_prev = item->ri_next = item;
1523                 *q = item;
1524         } else {
1525                 item->ri_next           = *q;
1526                 item->ri_prev           = (*q)->ri_prev;
1527                 (*q)->ri_prev           = item;
1528                 item->ri_prev->ri_next  = item;
1529         }
1530 }
1531
1532 STATIC void
1533 xlog_recover_insert_item_frontq(
1534         xlog_recover_item_t     **q,
1535         xlog_recover_item_t     *item)
1536 {
1537         xlog_recover_insert_item_backq(q, item);
1538         *q = item;
1539 }
1540
1541 STATIC int
1542 xlog_recover_reorder_trans(
1543         xlog_recover_t          *trans)
1544 {
1545         xlog_recover_item_t     *first_item, *itemq, *itemq_next;
1546         xfs_buf_log_format_t    *buf_f;
1547         ushort                  flags = 0;
1548
1549         first_item = itemq = trans->r_itemq;
1550         trans->r_itemq = NULL;
1551         do {
1552                 itemq_next = itemq->ri_next;
1553                 buf_f = (xfs_buf_log_format_t *)itemq->ri_buf[0].i_addr;
1554
1555                 switch (ITEM_TYPE(itemq)) {
1556                 case XFS_LI_BUF:
1557                         flags = buf_f->blf_flags;
1558                         if (!(flags & XFS_BLI_CANCEL)) {
1559                                 xlog_recover_insert_item_frontq(&trans->r_itemq,
1560                                                                 itemq);
1561                                 break;
1562                         }
1563                 case XFS_LI_INODE:
1564                 case XFS_LI_DQUOT:
1565                 case XFS_LI_QUOTAOFF:
1566                 case XFS_LI_EFD:
1567                 case XFS_LI_EFI:
1568                         xlog_recover_insert_item_backq(&trans->r_itemq, itemq);
1569                         break;
1570                 default:
1571                         xlog_warn(
1572         "XFS: xlog_recover_reorder_trans: unrecognized type of log operation");
1573                         ASSERT(0);
1574                         return XFS_ERROR(EIO);
1575                 }
1576                 itemq = itemq_next;
1577         } while (first_item != itemq);
1578         return 0;
1579 }
1580
1581 /*
1582  * Build up the table of buf cancel records so that we don't replay
1583  * cancelled data in the second pass.  For buffer records that are
1584  * not cancel records, there is nothing to do here so we just return.
1585  *
1586  * If we get a cancel record which is already in the table, this indicates
1587  * that the buffer was cancelled multiple times.  In order to ensure
1588  * that during pass 2 we keep the record in the table until we reach its
1589  * last occurrence in the log, we keep a reference count in the cancel
1590  * record in the table to tell us how many times we expect to see this
1591  * record during the second pass.
1592  */
1593 STATIC void
1594 xlog_recover_do_buffer_pass1(
1595         xlog_t                  *log,
1596         xfs_buf_log_format_t    *buf_f)
1597 {
1598         xfs_buf_cancel_t        *bcp;
1599         xfs_buf_cancel_t        *nextp;
1600         xfs_buf_cancel_t        *prevp;
1601         xfs_buf_cancel_t        **bucket;
1602         xfs_daddr_t             blkno = 0;
1603         uint                    len = 0;
1604         ushort                  flags = 0;
1605
1606         switch (buf_f->blf_type) {
1607         case XFS_LI_BUF:
1608                 blkno = buf_f->blf_blkno;
1609                 len = buf_f->blf_len;
1610                 flags = buf_f->blf_flags;
1611                 break;
1612         }
1613
1614         /*
1615          * If this isn't a cancel buffer item, then just return.
1616          */
1617         if (!(flags & XFS_BLI_CANCEL))
1618                 return;
1619
1620         /*
1621          * Insert an xfs_buf_cancel record into the hash table of
1622          * them.  If there is already an identical record, bump
1623          * its reference count.
1624          */
1625         bucket = &log->l_buf_cancel_table[(__uint64_t)blkno %
1626                                           XLOG_BC_TABLE_SIZE];
1627         /*
1628          * If the hash bucket is empty then just insert a new record into
1629          * the bucket.
1630          */
1631         if (*bucket == NULL) {
1632                 bcp = (xfs_buf_cancel_t *)kmem_alloc(sizeof(xfs_buf_cancel_t),
1633                                                      KM_SLEEP);
1634                 bcp->bc_blkno = blkno;
1635                 bcp->bc_len = len;
1636                 bcp->bc_refcount = 1;
1637                 bcp->bc_next = NULL;
1638                 *bucket = bcp;
1639                 return;
1640         }
1641
1642         /*
1643          * The hash bucket is not empty, so search for duplicates of our
1644          * record.  If we find one them just bump its refcount.  If not
1645          * then add us at the end of the list.
1646          */
1647         prevp = NULL;
1648         nextp = *bucket;
1649         while (nextp != NULL) {
1650                 if (nextp->bc_blkno == blkno && nextp->bc_len == len) {
1651                         nextp->bc_refcount++;
1652                         return;
1653                 }
1654                 prevp = nextp;
1655                 nextp = nextp->bc_next;
1656         }
1657         ASSERT(prevp != NULL);
1658         bcp = (xfs_buf_cancel_t *)kmem_alloc(sizeof(xfs_buf_cancel_t),
1659                                              KM_SLEEP);
1660         bcp->bc_blkno = blkno;
1661         bcp->bc_len = len;
1662         bcp->bc_refcount = 1;
1663         bcp->bc_next = NULL;
1664         prevp->bc_next = bcp;
1665 }
1666
1667 /*
1668  * Check to see whether the buffer being recovered has a corresponding
1669  * entry in the buffer cancel record table.  If it does then return 1
1670  * so that it will be cancelled, otherwise return 0.  If the buffer is
1671  * actually a buffer cancel item (XFS_BLI_CANCEL is set), then decrement
1672  * the refcount on the entry in the table and remove it from the table
1673  * if this is the last reference.
1674  *
1675  * We remove the cancel record from the table when we encounter its
1676  * last occurrence in the log so that if the same buffer is re-used
1677  * again after its last cancellation we actually replay the changes
1678  * made at that point.
1679  */
1680 STATIC int
1681 xlog_check_buffer_cancelled(
1682         xlog_t                  *log,
1683         xfs_daddr_t             blkno,
1684         uint                    len,
1685         ushort                  flags)
1686 {
1687         xfs_buf_cancel_t        *bcp;
1688         xfs_buf_cancel_t        *prevp;
1689         xfs_buf_cancel_t        **bucket;
1690
1691         if (log->l_buf_cancel_table == NULL) {
1692                 /*
1693                  * There is nothing in the table built in pass one,
1694                  * so this buffer must not be cancelled.
1695                  */
1696                 ASSERT(!(flags & XFS_BLI_CANCEL));
1697                 return 0;
1698         }
1699
1700         bucket = &log->l_buf_cancel_table[(__uint64_t)blkno %
1701                                           XLOG_BC_TABLE_SIZE];
1702         bcp = *bucket;
1703         if (bcp == NULL) {
1704                 /*
1705                  * There is no corresponding entry in the table built
1706                  * in pass one, so this buffer has not been cancelled.
1707                  */
1708                 ASSERT(!(flags & XFS_BLI_CANCEL));
1709                 return 0;
1710         }
1711
1712         /*
1713          * Search for an entry in the buffer cancel table that
1714          * matches our buffer.
1715          */
1716         prevp = NULL;
1717         while (bcp != NULL) {
1718                 if (bcp->bc_blkno == blkno && bcp->bc_len == len) {
1719                         /*
1720                          * We've go a match, so return 1 so that the
1721                          * recovery of this buffer is cancelled.
1722                          * If this buffer is actually a buffer cancel
1723                          * log item, then decrement the refcount on the
1724                          * one in the table and remove it if this is the
1725                          * last reference.
1726                          */
1727                         if (flags & XFS_BLI_CANCEL) {
1728                                 bcp->bc_refcount--;
1729                                 if (bcp->bc_refcount == 0) {
1730                                         if (prevp == NULL) {
1731                                                 *bucket = bcp->bc_next;
1732                                         } else {
1733                                                 prevp->bc_next = bcp->bc_next;
1734                                         }
1735                                         kmem_free(bcp);
1736                                 }
1737                         }
1738                         return 1;
1739                 }
1740                 prevp = bcp;
1741                 bcp = bcp->bc_next;
1742         }
1743         /*
1744          * We didn't find a corresponding entry in the table, so
1745          * return 0 so that the buffer is NOT cancelled.
1746          */
1747         ASSERT(!(flags & XFS_BLI_CANCEL));
1748         return 0;
1749 }
1750
1751 STATIC int
1752 xlog_recover_do_buffer_pass2(
1753         xlog_t                  *log,
1754         xfs_buf_log_format_t    *buf_f)
1755 {
1756         xfs_daddr_t             blkno = 0;
1757         ushort                  flags = 0;
1758         uint                    len = 0;
1759
1760         switch (buf_f->blf_type) {
1761         case XFS_LI_BUF:
1762                 blkno = buf_f->blf_blkno;
1763                 flags = buf_f->blf_flags;
1764                 len = buf_f->blf_len;
1765                 break;
1766         }
1767
1768         return xlog_check_buffer_cancelled(log, blkno, len, flags);
1769 }
1770
1771 /*
1772  * Perform recovery for a buffer full of inodes.  In these buffers,
1773  * the only data which should be recovered is that which corresponds
1774  * to the di_next_unlinked pointers in the on disk inode structures.
1775  * The rest of the data for the inodes is always logged through the
1776  * inodes themselves rather than the inode buffer and is recovered
1777  * in xlog_recover_do_inode_trans().
1778  *
1779  * The only time when buffers full of inodes are fully recovered is
1780  * when the buffer is full of newly allocated inodes.  In this case
1781  * the buffer will not be marked as an inode buffer and so will be
1782  * sent to xlog_recover_do_reg_buffer() below during recovery.
1783  */
1784 STATIC int
1785 xlog_recover_do_inode_buffer(
1786         xfs_mount_t             *mp,
1787         xlog_recover_item_t     *item,
1788         xfs_buf_t               *bp,
1789         xfs_buf_log_format_t    *buf_f)
1790 {
1791         int                     i;
1792         int                     item_index;
1793         int                     bit;
1794         int                     nbits;
1795         int                     reg_buf_offset;
1796         int                     reg_buf_bytes;
1797         int                     next_unlinked_offset;
1798         int                     inodes_per_buf;
1799         xfs_agino_t             *logged_nextp;
1800         xfs_agino_t             *buffer_nextp;
1801         unsigned int            *data_map = NULL;
1802         unsigned int            map_size = 0;
1803
1804         switch (buf_f->blf_type) {
1805         case XFS_LI_BUF:
1806                 data_map = buf_f->blf_data_map;
1807                 map_size = buf_f->blf_map_size;
1808                 break;
1809         }
1810         /*
1811          * Set the variables corresponding to the current region to
1812          * 0 so that we'll initialize them on the first pass through
1813          * the loop.
1814          */
1815         reg_buf_offset = 0;
1816         reg_buf_bytes = 0;
1817         bit = 0;
1818         nbits = 0;
1819         item_index = 0;
1820         inodes_per_buf = XFS_BUF_COUNT(bp) >> mp->m_sb.sb_inodelog;
1821         for (i = 0; i < inodes_per_buf; i++) {
1822                 next_unlinked_offset = (i * mp->m_sb.sb_inodesize) +
1823                         offsetof(xfs_dinode_t, di_next_unlinked);
1824
1825                 while (next_unlinked_offset >=
1826                        (reg_buf_offset + reg_buf_bytes)) {
1827                         /*
1828                          * The next di_next_unlinked field is beyond
1829                          * the current logged region.  Find the next
1830                          * logged region that contains or is beyond
1831                          * the current di_next_unlinked field.
1832                          */
1833                         bit += nbits;
1834                         bit = xfs_next_bit(data_map, map_size, bit);
1835
1836                         /*
1837                          * If there are no more logged regions in the
1838                          * buffer, then we're done.
1839                          */
1840                         if (bit == -1) {
1841                                 return 0;
1842                         }
1843
1844                         nbits = xfs_contig_bits(data_map, map_size,
1845                                                          bit);
1846                         ASSERT(nbits > 0);
1847                         reg_buf_offset = bit << XFS_BLI_SHIFT;
1848                         reg_buf_bytes = nbits << XFS_BLI_SHIFT;
1849                         item_index++;
1850                 }
1851
1852                 /*
1853                  * If the current logged region starts after the current
1854                  * di_next_unlinked field, then move on to the next
1855                  * di_next_unlinked field.
1856                  */
1857                 if (next_unlinked_offset < reg_buf_offset) {
1858                         continue;
1859                 }
1860
1861                 ASSERT(item->ri_buf[item_index].i_addr != NULL);
1862                 ASSERT((item->ri_buf[item_index].i_len % XFS_BLI_CHUNK) == 0);
1863                 ASSERT((reg_buf_offset + reg_buf_bytes) <= XFS_BUF_COUNT(bp));
1864
1865                 /*
1866                  * The current logged region contains a copy of the
1867                  * current di_next_unlinked field.  Extract its value
1868                  * and copy it to the buffer copy.
1869                  */
1870                 logged_nextp = (xfs_agino_t *)
1871                                ((char *)(item->ri_buf[item_index].i_addr) +
1872                                 (next_unlinked_offset - reg_buf_offset));
1873                 if (unlikely(*logged_nextp == 0)) {
1874                         xfs_fs_cmn_err(CE_ALERT, mp,
1875                                 "bad inode buffer log record (ptr = 0x%p, bp = 0x%p).  XFS trying to replay bad (0) inode di_next_unlinked field",
1876                                 item, bp);
1877                         XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
1878                                          XFS_ERRLEVEL_LOW, mp);
1879                         return XFS_ERROR(EFSCORRUPTED);
1880                 }
1881
1882                 buffer_nextp = (xfs_agino_t *)xfs_buf_offset(bp,
1883                                               next_unlinked_offset);
1884                 *buffer_nextp = *logged_nextp;
1885         }
1886
1887         return 0;
1888 }
1889
1890 /*
1891  * Perform a 'normal' buffer recovery.  Each logged region of the
1892  * buffer should be copied over the corresponding region in the
1893  * given buffer.  The bitmap in the buf log format structure indicates
1894  * where to place the logged data.
1895  */
1896 /*ARGSUSED*/
1897 STATIC void
1898 xlog_recover_do_reg_buffer(
1899         xlog_recover_item_t     *item,
1900         xfs_buf_t               *bp,
1901         xfs_buf_log_format_t    *buf_f)
1902 {
1903         int                     i;
1904         int                     bit;
1905         int                     nbits;
1906         unsigned int            *data_map = NULL;
1907         unsigned int            map_size = 0;
1908         int                     error;
1909
1910         switch (buf_f->blf_type) {
1911         case XFS_LI_BUF:
1912                 data_map = buf_f->blf_data_map;
1913                 map_size = buf_f->blf_map_size;
1914                 break;
1915         }
1916         bit = 0;
1917         i = 1;  /* 0 is the buf format structure */
1918         while (1) {
1919                 bit = xfs_next_bit(data_map, map_size, bit);
1920                 if (bit == -1)
1921                         break;
1922                 nbits = xfs_contig_bits(data_map, map_size, bit);
1923                 ASSERT(nbits > 0);
1924                 ASSERT(item->ri_buf[i].i_addr != NULL);
1925                 ASSERT(item->ri_buf[i].i_len % XFS_BLI_CHUNK == 0);
1926                 ASSERT(XFS_BUF_COUNT(bp) >=
1927                        ((uint)bit << XFS_BLI_SHIFT)+(nbits<<XFS_BLI_SHIFT));
1928
1929                 /*
1930                  * Do a sanity check if this is a dquot buffer. Just checking
1931                  * the first dquot in the buffer should do. XXXThis is
1932                  * probably a good thing to do for other buf types also.
1933                  */
1934                 error = 0;
1935                 if (buf_f->blf_flags &
1936                    (XFS_BLI_UDQUOT_BUF|XFS_BLI_PDQUOT_BUF|XFS_BLI_GDQUOT_BUF)) {
1937                         error = xfs_qm_dqcheck((xfs_disk_dquot_t *)
1938                                                item->ri_buf[i].i_addr,
1939                                                -1, 0, XFS_QMOPT_DOWARN,
1940                                                "dquot_buf_recover");
1941                 }
1942                 if (!error)
1943                         memcpy(xfs_buf_offset(bp,
1944                                 (uint)bit << XFS_BLI_SHIFT),    /* dest */
1945                                 item->ri_buf[i].i_addr,         /* source */
1946                                 nbits<<XFS_BLI_SHIFT);          /* length */
1947                 i++;
1948                 bit += nbits;
1949         }
1950
1951         /* Shouldn't be any more regions */
1952         ASSERT(i == item->ri_total);
1953 }
1954
1955 /*
1956  * Do some primitive error checking on ondisk dquot data structures.
1957  */
1958 int
1959 xfs_qm_dqcheck(
1960         xfs_disk_dquot_t *ddq,
1961         xfs_dqid_t       id,
1962         uint             type,    /* used only when IO_dorepair is true */
1963         uint             flags,
1964         char             *str)
1965 {
1966         xfs_dqblk_t      *d = (xfs_dqblk_t *)ddq;
1967         int             errs = 0;
1968
1969         /*
1970          * We can encounter an uninitialized dquot buffer for 2 reasons:
1971          * 1. If we crash while deleting the quotainode(s), and those blks got
1972          *    used for user data. This is because we take the path of regular
1973          *    file deletion; however, the size field of quotainodes is never
1974          *    updated, so all the tricks that we play in itruncate_finish
1975          *    don't quite matter.
1976          *
1977          * 2. We don't play the quota buffers when there's a quotaoff logitem.
1978          *    But the allocation will be replayed so we'll end up with an
1979          *    uninitialized quota block.
1980          *
1981          * This is all fine; things are still consistent, and we haven't lost
1982          * any quota information. Just don't complain about bad dquot blks.
1983          */
1984         if (be16_to_cpu(ddq->d_magic) != XFS_DQUOT_MAGIC) {
1985                 if (flags & XFS_QMOPT_DOWARN)
1986                         cmn_err(CE_ALERT,
1987                         "%s : XFS dquot ID 0x%x, magic 0x%x != 0x%x",
1988                         str, id, be16_to_cpu(ddq->d_magic), XFS_DQUOT_MAGIC);
1989                 errs++;
1990         }
1991         if (ddq->d_version != XFS_DQUOT_VERSION) {
1992                 if (flags & XFS_QMOPT_DOWARN)
1993                         cmn_err(CE_ALERT,
1994                         "%s : XFS dquot ID 0x%x, version 0x%x != 0x%x",
1995                         str, id, ddq->d_version, XFS_DQUOT_VERSION);
1996                 errs++;
1997         }
1998
1999         if (ddq->d_flags != XFS_DQ_USER &&
2000             ddq->d_flags != XFS_DQ_PROJ &&
2001             ddq->d_flags != XFS_DQ_GROUP) {
2002                 if (flags & XFS_QMOPT_DOWARN)
2003                         cmn_err(CE_ALERT,
2004                         "%s : XFS dquot ID 0x%x, unknown flags 0x%x",
2005                         str, id, ddq->d_flags);
2006                 errs++;
2007         }
2008
2009         if (id != -1 && id != be32_to_cpu(ddq->d_id)) {
2010                 if (flags & XFS_QMOPT_DOWARN)
2011                         cmn_err(CE_ALERT,
2012                         "%s : ondisk-dquot 0x%p, ID mismatch: "
2013                         "0x%x expected, found id 0x%x",
2014                         str, ddq, id, be32_to_cpu(ddq->d_id));
2015                 errs++;
2016         }
2017
2018         if (!errs && ddq->d_id) {
2019                 if (ddq->d_blk_softlimit &&
2020                     be64_to_cpu(ddq->d_bcount) >=
2021                                 be64_to_cpu(ddq->d_blk_softlimit)) {
2022                         if (!ddq->d_btimer) {
2023                                 if (flags & XFS_QMOPT_DOWARN)
2024                                         cmn_err(CE_ALERT,
2025                                         "%s : Dquot ID 0x%x (0x%p) "
2026                                         "BLK TIMER NOT STARTED",
2027                                         str, (int)be32_to_cpu(ddq->d_id), ddq);
2028                                 errs++;
2029                         }
2030                 }
2031                 if (ddq->d_ino_softlimit &&
2032                     be64_to_cpu(ddq->d_icount) >=
2033                                 be64_to_cpu(ddq->d_ino_softlimit)) {
2034                         if (!ddq->d_itimer) {
2035                                 if (flags & XFS_QMOPT_DOWARN)
2036                                         cmn_err(CE_ALERT,
2037                                         "%s : Dquot ID 0x%x (0x%p) "
2038                                         "INODE TIMER NOT STARTED",
2039                                         str, (int)be32_to_cpu(ddq->d_id), ddq);
2040                                 errs++;
2041                         }
2042                 }
2043                 if (ddq->d_rtb_softlimit &&
2044                     be64_to_cpu(ddq->d_rtbcount) >=
2045                                 be64_to_cpu(ddq->d_rtb_softlimit)) {
2046                         if (!ddq->d_rtbtimer) {
2047                                 if (flags & XFS_QMOPT_DOWARN)
2048                                         cmn_err(CE_ALERT,
2049                                         "%s : Dquot ID 0x%x (0x%p) "
2050                                         "RTBLK TIMER NOT STARTED",
2051                                         str, (int)be32_to_cpu(ddq->d_id), ddq);
2052                                 errs++;
2053                         }
2054                 }
2055         }
2056
2057         if (!errs || !(flags & XFS_QMOPT_DQREPAIR))
2058                 return errs;
2059
2060         if (flags & XFS_QMOPT_DOWARN)
2061                 cmn_err(CE_NOTE, "Re-initializing dquot ID 0x%x", id);
2062
2063         /*
2064          * Typically, a repair is only requested by quotacheck.
2065          */
2066         ASSERT(id != -1);
2067         ASSERT(flags & XFS_QMOPT_DQREPAIR);
2068         memset(d, 0, sizeof(xfs_dqblk_t));
2069
2070         d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
2071         d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
2072         d->dd_diskdq.d_flags = type;
2073         d->dd_diskdq.d_id = cpu_to_be32(id);
2074
2075         return errs;
2076 }
2077
2078 /*
2079  * Perform a dquot buffer recovery.
2080  * Simple algorithm: if we have found a QUOTAOFF logitem of the same type
2081  * (ie. USR or GRP), then just toss this buffer away; don't recover it.
2082  * Else, treat it as a regular buffer and do recovery.
2083  */
2084 STATIC void
2085 xlog_recover_do_dquot_buffer(
2086         xfs_mount_t             *mp,
2087         xlog_t                  *log,
2088         xlog_recover_item_t     *item,
2089         xfs_buf_t               *bp,
2090         xfs_buf_log_format_t    *buf_f)
2091 {
2092         uint                    type;
2093
2094         /*
2095          * Filesystems are required to send in quota flags at mount time.
2096          */
2097         if (mp->m_qflags == 0) {
2098                 return;
2099         }
2100
2101         type = 0;
2102         if (buf_f->blf_flags & XFS_BLI_UDQUOT_BUF)
2103                 type |= XFS_DQ_USER;
2104         if (buf_f->blf_flags & XFS_BLI_PDQUOT_BUF)
2105                 type |= XFS_DQ_PROJ;
2106         if (buf_f->blf_flags & XFS_BLI_GDQUOT_BUF)
2107                 type |= XFS_DQ_GROUP;
2108         /*
2109          * This type of quotas was turned off, so ignore this buffer
2110          */
2111         if (log->l_quotaoffs_flag & type)
2112                 return;
2113
2114         xlog_recover_do_reg_buffer(item, bp, buf_f);
2115 }
2116
2117 /*
2118  * This routine replays a modification made to a buffer at runtime.
2119  * There are actually two types of buffer, regular and inode, which
2120  * are handled differently.  Inode buffers are handled differently
2121  * in that we only recover a specific set of data from them, namely
2122  * the inode di_next_unlinked fields.  This is because all other inode
2123  * data is actually logged via inode records and any data we replay
2124  * here which overlaps that may be stale.
2125  *
2126  * When meta-data buffers are freed at run time we log a buffer item
2127  * with the XFS_BLI_CANCEL bit set to indicate that previous copies
2128  * of the buffer in the log should not be replayed at recovery time.
2129  * This is so that if the blocks covered by the buffer are reused for
2130  * file data before we crash we don't end up replaying old, freed
2131  * meta-data into a user's file.
2132  *
2133  * To handle the cancellation of buffer log items, we make two passes
2134  * over the log during recovery.  During the first we build a table of
2135  * those buffers which have been cancelled, and during the second we
2136  * only replay those buffers which do not have corresponding cancel
2137  * records in the table.  See xlog_recover_do_buffer_pass[1,2] above
2138  * for more details on the implementation of the table of cancel records.
2139  */
2140 STATIC int
2141 xlog_recover_do_buffer_trans(
2142         xlog_t                  *log,
2143         xlog_recover_item_t     *item,
2144         int                     pass)
2145 {
2146         xfs_buf_log_format_t    *buf_f;
2147         xfs_mount_t             *mp;
2148         xfs_buf_t               *bp;
2149         int                     error;
2150         int                     cancel;
2151         xfs_daddr_t             blkno;
2152         int                     len;
2153         ushort                  flags;
2154
2155         buf_f = (xfs_buf_log_format_t *)item->ri_buf[0].i_addr;
2156
2157         if (pass == XLOG_RECOVER_PASS1) {
2158                 /*
2159                  * In this pass we're only looking for buf items
2160                  * with the XFS_BLI_CANCEL bit set.
2161                  */
2162                 xlog_recover_do_buffer_pass1(log, buf_f);
2163                 return 0;
2164         } else {
2165                 /*
2166                  * In this pass we want to recover all the buffers
2167                  * which have not been cancelled and are not
2168                  * cancellation buffers themselves.  The routine
2169                  * we call here will tell us whether or not to
2170                  * continue with the replay of this buffer.
2171                  */
2172                 cancel = xlog_recover_do_buffer_pass2(log, buf_f);
2173                 if (cancel) {
2174                         return 0;
2175                 }
2176         }
2177         switch (buf_f->blf_type) {
2178         case XFS_LI_BUF:
2179                 blkno = buf_f->blf_blkno;
2180                 len = buf_f->blf_len;
2181                 flags = buf_f->blf_flags;
2182                 break;
2183         default:
2184                 xfs_fs_cmn_err(CE_ALERT, log->l_mp,
2185                         "xfs_log_recover: unknown buffer type 0x%x, logdev %s",
2186                         buf_f->blf_type, log->l_mp->m_logname ?
2187                         log->l_mp->m_logname : "internal");
2188                 XFS_ERROR_REPORT("xlog_recover_do_buffer_trans",
2189                                  XFS_ERRLEVEL_LOW, log->l_mp);
2190                 return XFS_ERROR(EFSCORRUPTED);
2191         }
2192
2193         mp = log->l_mp;
2194         if (flags & XFS_BLI_INODE_BUF) {
2195                 bp = xfs_buf_read_flags(mp->m_ddev_targp, blkno, len,
2196                                                                 XFS_BUF_LOCK);
2197         } else {
2198                 bp = xfs_buf_read(mp->m_ddev_targp, blkno, len, 0);
2199         }
2200         if (XFS_BUF_ISERROR(bp)) {
2201                 xfs_ioerror_alert("xlog_recover_do..(read#1)", log->l_mp,
2202                                   bp, blkno);
2203                 error = XFS_BUF_GETERROR(bp);
2204                 xfs_buf_relse(bp);
2205                 return error;
2206         }
2207
2208         error = 0;
2209         if (flags & XFS_BLI_INODE_BUF) {
2210                 error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
2211         } else if (flags &
2212                   (XFS_BLI_UDQUOT_BUF|XFS_BLI_PDQUOT_BUF|XFS_BLI_GDQUOT_BUF)) {
2213                 xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
2214         } else {
2215                 xlog_recover_do_reg_buffer(item, bp, buf_f);
2216         }
2217         if (error)
2218                 return XFS_ERROR(error);
2219
2220         /*
2221          * Perform delayed write on the buffer.  Asynchronous writes will be
2222          * slower when taking into account all the buffers to be flushed.
2223          *
2224          * Also make sure that only inode buffers with good sizes stay in
2225          * the buffer cache.  The kernel moves inodes in buffers of 1 block
2226          * or XFS_INODE_CLUSTER_SIZE bytes, whichever is bigger.  The inode
2227          * buffers in the log can be a different size if the log was generated
2228          * by an older kernel using unclustered inode buffers or a newer kernel
2229          * running with a different inode cluster size.  Regardless, if the
2230          * the inode buffer size isn't MAX(blocksize, XFS_INODE_CLUSTER_SIZE)
2231          * for *our* value of XFS_INODE_CLUSTER_SIZE, then we need to keep
2232          * the buffer out of the buffer cache so that the buffer won't
2233          * overlap with future reads of those inodes.
2234          */
2235         if (XFS_DINODE_MAGIC ==
2236             be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
2237             (XFS_BUF_COUNT(bp) != MAX(log->l_mp->m_sb.sb_blocksize,
2238                         (__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {
2239                 XFS_BUF_STALE(bp);
2240                 error = xfs_bwrite(mp, bp);
2241         } else {
2242                 ASSERT(bp->b_mount == NULL || bp->b_mount == mp);
2243                 bp->b_mount = mp;
2244                 XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
2245                 xfs_bdwrite(mp, bp);
2246         }
2247
2248         return (error);
2249 }
2250
2251 STATIC int
2252 xlog_recover_do_inode_trans(
2253         xlog_t                  *log,
2254         xlog_recover_item_t     *item,
2255         int                     pass)
2256 {
2257         xfs_inode_log_format_t  *in_f;
2258         xfs_mount_t             *mp;
2259         xfs_buf_t               *bp;
2260         xfs_dinode_t            *dip;
2261         xfs_ino_t               ino;
2262         int                     len;
2263         xfs_caddr_t             src;
2264         xfs_caddr_t             dest;
2265         int                     error;
2266         int                     attr_index;
2267         uint                    fields;
2268         xfs_icdinode_t          *dicp;
2269         int                     need_free = 0;
2270
2271         if (pass == XLOG_RECOVER_PASS1) {
2272                 return 0;
2273         }
2274
2275         if (item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t)) {
2276                 in_f = (xfs_inode_log_format_t *)item->ri_buf[0].i_addr;
2277         } else {
2278                 in_f = (xfs_inode_log_format_t *)kmem_alloc(
2279                         sizeof(xfs_inode_log_format_t), KM_SLEEP);
2280                 need_free = 1;
2281                 error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
2282                 if (error)
2283                         goto error;
2284         }
2285         ino = in_f->ilf_ino;
2286         mp = log->l_mp;
2287
2288         /*
2289          * Inode buffers can be freed, look out for it,
2290          * and do not replay the inode.
2291          */
2292         if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno,
2293                                         in_f->ilf_len, 0)) {
2294                 error = 0;
2295                 goto error;
2296         }
2297
2298         bp = xfs_buf_read_flags(mp->m_ddev_targp, in_f->ilf_blkno,
2299                                 in_f->ilf_len, XFS_BUF_LOCK);
2300         if (XFS_BUF_ISERROR(bp)) {
2301                 xfs_ioerror_alert("xlog_recover_do..(read#2)", mp,
2302                                   bp, in_f->ilf_blkno);
2303                 error = XFS_BUF_GETERROR(bp);
2304                 xfs_buf_relse(bp);
2305                 goto error;
2306         }
2307         error = 0;
2308         ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
2309         dip = (xfs_dinode_t *)xfs_buf_offset(bp, in_f->ilf_boffset);
2310
2311         /*
2312          * Make sure the place we're flushing out to really looks
2313          * like an inode!
2314          */
2315         if (unlikely(be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC)) {
2316                 xfs_buf_relse(bp);
2317                 xfs_fs_cmn_err(CE_ALERT, mp,
2318                         "xfs_inode_recover: Bad inode magic number, dino ptr = 0x%p, dino bp = 0x%p, ino = %Ld",
2319                         dip, bp, ino);
2320                 XFS_ERROR_REPORT("xlog_recover_do_inode_trans(1)",
2321                                  XFS_ERRLEVEL_LOW, mp);
2322                 error = EFSCORRUPTED;
2323                 goto error;
2324         }
2325         dicp = (xfs_icdinode_t *)(item->ri_buf[1].i_addr);
2326         if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) {
2327                 xfs_buf_relse(bp);
2328                 xfs_fs_cmn_err(CE_ALERT, mp,
2329                         "xfs_inode_recover: Bad inode log record, rec ptr 0x%p, ino %Ld",
2330                         item, ino);
2331                 XFS_ERROR_REPORT("xlog_recover_do_inode_trans(2)",
2332                                  XFS_ERRLEVEL_LOW, mp);
2333                 error = EFSCORRUPTED;
2334                 goto error;
2335         }
2336
2337         /* Skip replay when the on disk inode is newer than the log one */
2338         if (dicp->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
2339                 /*
2340                  * Deal with the wrap case, DI_MAX_FLUSH is less
2341                  * than smaller numbers
2342                  */
2343                 if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
2344                     dicp->di_flushiter < (DI_MAX_FLUSH >> 1)) {
2345                         /* do nothing */
2346                 } else {
2347                         xfs_buf_relse(bp);
2348                         error = 0;
2349                         goto error;
2350                 }
2351         }
2352         /* Take the opportunity to reset the flush iteration count */
2353         dicp->di_flushiter = 0;
2354
2355         if (unlikely((dicp->di_mode & S_IFMT) == S_IFREG)) {
2356                 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2357                     (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
2358                         XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(3)",
2359                                          XFS_ERRLEVEL_LOW, mp, dicp);
2360                         xfs_buf_relse(bp);
2361                         xfs_fs_cmn_err(CE_ALERT, mp,
2362                                 "xfs_inode_recover: Bad regular inode log record, rec ptr 0x%p, ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2363                                 item, dip, bp, ino);
2364                         error = EFSCORRUPTED;
2365                         goto error;
2366                 }
2367         } else if (unlikely((dicp->di_mode & S_IFMT) == S_IFDIR)) {
2368                 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2369                     (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
2370                     (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
2371                         XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(4)",
2372                                              XFS_ERRLEVEL_LOW, mp, dicp);
2373                         xfs_buf_relse(bp);
2374                         xfs_fs_cmn_err(CE_ALERT, mp,
2375                                 "xfs_inode_recover: Bad dir inode log record, rec ptr 0x%p, ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2376                                 item, dip, bp, ino);
2377                         error = EFSCORRUPTED;
2378                         goto error;
2379                 }
2380         }
2381         if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){
2382                 XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(5)",
2383                                      XFS_ERRLEVEL_LOW, mp, dicp);
2384                 xfs_buf_relse(bp);
2385                 xfs_fs_cmn_err(CE_ALERT, mp,
2386                         "xfs_inode_recover: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, dino bp 0x%p, ino %Ld, total extents = %d, nblocks = %Ld",
2387                         item, dip, bp, ino,
2388                         dicp->di_nextents + dicp->di_anextents,
2389                         dicp->di_nblocks);
2390                 error = EFSCORRUPTED;
2391                 goto error;
2392         }
2393         if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
2394                 XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(6)",
2395                                      XFS_ERRLEVEL_LOW, mp, dicp);
2396                 xfs_buf_relse(bp);
2397                 xfs_fs_cmn_err(CE_ALERT, mp,
2398                         "xfs_inode_recover: Bad inode log rec ptr 0x%p, dino ptr 0x%p, dino bp 0x%p, ino %Ld, forkoff 0x%x",
2399                         item, dip, bp, ino, dicp->di_forkoff);
2400                 error = EFSCORRUPTED;
2401                 goto error;
2402         }
2403         if (unlikely(item->ri_buf[1].i_len > sizeof(struct xfs_icdinode))) {
2404                 XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(7)",
2405                                      XFS_ERRLEVEL_LOW, mp, dicp);
2406                 xfs_buf_relse(bp);
2407                 xfs_fs_cmn_err(CE_ALERT, mp,
2408                         "xfs_inode_recover: Bad inode log record length %d, rec ptr 0x%p",
2409                         item->ri_buf[1].i_len, item);
2410                 error = EFSCORRUPTED;
2411                 goto error;
2412         }
2413
2414         /* The core is in in-core format */
2415         xfs_dinode_to_disk(dip, (xfs_icdinode_t *)item->ri_buf[1].i_addr);
2416
2417         /* the rest is in on-disk format */
2418         if (item->ri_buf[1].i_len > sizeof(struct xfs_icdinode)) {
2419                 memcpy((xfs_caddr_t) dip + sizeof(struct xfs_icdinode),
2420                         item->ri_buf[1].i_addr + sizeof(struct xfs_icdinode),
2421                         item->ri_buf[1].i_len  - sizeof(struct xfs_icdinode));
2422         }
2423
2424         fields = in_f->ilf_fields;
2425         switch (fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) {
2426         case XFS_ILOG_DEV:
2427                 xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev);
2428                 break;
2429         case XFS_ILOG_UUID:
2430                 memcpy(XFS_DFORK_DPTR(dip),
2431                        &in_f->ilf_u.ilfu_uuid,
2432                        sizeof(uuid_t));
2433                 break;
2434         }
2435
2436         if (in_f->ilf_size == 2)
2437                 goto write_inode_buffer;
2438         len = item->ri_buf[2].i_len;
2439         src = item->ri_buf[2].i_addr;
2440         ASSERT(in_f->ilf_size <= 4);
2441         ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK));
2442         ASSERT(!(fields & XFS_ILOG_DFORK) ||
2443                (len == in_f->ilf_dsize));
2444
2445         switch (fields & XFS_ILOG_DFORK) {
2446         case XFS_ILOG_DDATA:
2447         case XFS_ILOG_DEXT:
2448                 memcpy(XFS_DFORK_DPTR(dip), src, len);
2449                 break;
2450
2451         case XFS_ILOG_DBROOT:
2452                 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, len,
2453                                  (xfs_bmdr_block_t *)XFS_DFORK_DPTR(dip),
2454                                  XFS_DFORK_DSIZE(dip, mp));
2455                 break;
2456
2457         default:
2458                 /*
2459                  * There are no data fork flags set.
2460                  */
2461                 ASSERT((fields & XFS_ILOG_DFORK) == 0);
2462                 break;
2463         }
2464
2465         /*
2466          * If we logged any attribute data, recover it.  There may or
2467          * may not have been any other non-core data logged in this
2468          * transaction.
2469          */
2470         if (in_f->ilf_fields & XFS_ILOG_AFORK) {
2471                 if (in_f->ilf_fields & XFS_ILOG_DFORK) {
2472                         attr_index = 3;
2473                 } else {
2474                         attr_index = 2;
2475                 }
2476                 len = item->ri_buf[attr_index].i_len;
2477                 src = item->ri_buf[attr_index].i_addr;
2478                 ASSERT(len == in_f->ilf_asize);
2479
2480                 switch (in_f->ilf_fields & XFS_ILOG_AFORK) {
2481                 case XFS_ILOG_ADATA:
2482                 case XFS_ILOG_AEXT:
2483                         dest = XFS_DFORK_APTR(dip);
2484                         ASSERT(len <= XFS_DFORK_ASIZE(dip, mp));
2485                         memcpy(dest, src, len);
2486                         break;
2487
2488                 case XFS_ILOG_ABROOT:
2489                         dest = XFS_DFORK_APTR(dip);
2490                         xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src,
2491                                          len, (xfs_bmdr_block_t*)dest,
2492                                          XFS_DFORK_ASIZE(dip, mp));
2493                         break;
2494
2495                 default:
2496                         xlog_warn("XFS: xlog_recover_do_inode_trans: Invalid flag");
2497                         ASSERT(0);
2498                         xfs_buf_relse(bp);
2499                         error = EIO;
2500                         goto error;
2501                 }
2502         }
2503
2504 write_inode_buffer:
2505         if (ITEM_TYPE(item) == XFS_LI_INODE) {
2506                 ASSERT(bp->b_mount == NULL || bp->b_mount == mp);
2507                 bp->b_mount = mp;
2508                 XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
2509                 xfs_bdwrite(mp, bp);
2510         } else {
2511                 XFS_BUF_STALE(bp);
2512                 error = xfs_bwrite(mp, bp);
2513         }
2514
2515 error:
2516         if (need_free)
2517                 kmem_free(in_f);
2518         return XFS_ERROR(error);
2519 }
2520
2521 /*
2522  * Recover QUOTAOFF records. We simply make a note of it in the xlog_t
2523  * structure, so that we know not to do any dquot item or dquot buffer recovery,
2524  * of that type.
2525  */
2526 STATIC int
2527 xlog_recover_do_quotaoff_trans(
2528         xlog_t                  *log,
2529         xlog_recover_item_t     *item,
2530         int                     pass)
2531 {
2532         xfs_qoff_logformat_t    *qoff_f;
2533
2534         if (pass == XLOG_RECOVER_PASS2) {
2535                 return (0);
2536         }
2537
2538         qoff_f = (xfs_qoff_logformat_t *)item->ri_buf[0].i_addr;
2539         ASSERT(qoff_f);
2540
2541         /*
2542          * The logitem format's flag tells us if this was user quotaoff,
2543          * group/project quotaoff or both.
2544          */
2545         if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
2546                 log->l_quotaoffs_flag |= XFS_DQ_USER;
2547         if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
2548                 log->l_quotaoffs_flag |= XFS_DQ_PROJ;
2549         if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
2550                 log->l_quotaoffs_flag |= XFS_DQ_GROUP;
2551
2552         return (0);
2553 }
2554
2555 /*
2556  * Recover a dquot record
2557  */
2558 STATIC int
2559 xlog_recover_do_dquot_trans(
2560         xlog_t                  *log,
2561         xlog_recover_item_t     *item,
2562         int                     pass)
2563 {
2564         xfs_mount_t             *mp;
2565         xfs_buf_t               *bp;
2566         struct xfs_disk_dquot   *ddq, *recddq;
2567         int                     error;
2568         xfs_dq_logformat_t      *dq_f;
2569         uint                    type;
2570
2571         if (pass == XLOG_RECOVER_PASS1) {
2572                 return 0;
2573         }
2574         mp = log->l_mp;
2575
2576         /*
2577          * Filesystems are required to send in quota flags at mount time.
2578          */
2579         if (mp->m_qflags == 0)
2580                 return (0);
2581
2582         recddq = (xfs_disk_dquot_t *)item->ri_buf[1].i_addr;
2583         ASSERT(recddq);
2584         /*
2585          * This type of quotas was turned off, so ignore this record.
2586          */
2587         type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
2588         ASSERT(type);
2589         if (log->l_quotaoffs_flag & type)
2590                 return (0);
2591
2592         /*
2593          * At this point we know that quota was _not_ turned off.
2594          * Since the mount flags are not indicating to us otherwise, this
2595          * must mean that quota is on, and the dquot needs to be replayed.
2596          * Remember that we may not have fully recovered the superblock yet,
2597          * so we can't do the usual trick of looking at the SB quota bits.
2598          *
2599          * The other possibility, of course, is that the quota subsystem was
2600          * removed since the last mount - ENOSYS.
2601          */
2602         dq_f = (xfs_dq_logformat_t *)item->ri_buf[0].i_addr;
2603         ASSERT(dq_f);
2604         if ((error = xfs_qm_dqcheck(recddq,
2605                            dq_f->qlf_id,
2606                            0, XFS_QMOPT_DOWARN,
2607                            "xlog_recover_do_dquot_trans (log copy)"))) {
2608                 return XFS_ERROR(EIO);
2609         }
2610         ASSERT(dq_f->qlf_len == 1);
2611
2612         error = xfs_read_buf(mp, mp->m_ddev_targp,
2613                              dq_f->qlf_blkno,
2614                              XFS_FSB_TO_BB(mp, dq_f->qlf_len),
2615                              0, &bp);
2616         if (error) {
2617                 xfs_ioerror_alert("xlog_recover_do..(read#3)", mp,
2618                                   bp, dq_f->qlf_blkno);
2619                 return error;
2620         }
2621         ASSERT(bp);
2622         ddq = (xfs_disk_dquot_t *)xfs_buf_offset(bp, dq_f->qlf_boffset);
2623
2624         /*
2625          * At least the magic num portion should be on disk because this
2626          * was among a chunk of dquots created earlier, and we did some
2627          * minimal initialization then.
2628          */
2629         if (xfs_qm_dqcheck(ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
2630                            "xlog_recover_do_dquot_trans")) {
2631                 xfs_buf_relse(bp);
2632                 return XFS_ERROR(EIO);
2633         }
2634
2635         memcpy(ddq, recddq, item->ri_buf[1].i_len);
2636
2637         ASSERT(dq_f->qlf_size == 2);
2638         ASSERT(bp->b_mount == NULL || bp->b_mount == mp);
2639         bp->b_mount = mp;
2640         XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
2641         xfs_bdwrite(mp, bp);
2642
2643         return (0);
2644 }
2645
2646 /*
2647  * This routine is called to create an in-core extent free intent
2648  * item from the efi format structure which was logged on disk.
2649  * It allocates an in-core efi, copies the extents from the format
2650  * structure into it, and adds the efi to the AIL with the given
2651  * LSN.
2652  */
2653 STATIC int
2654 xlog_recover_do_efi_trans(
2655         xlog_t                  *log,
2656         xlog_recover_item_t     *item,
2657         xfs_lsn_t               lsn,
2658         int                     pass)
2659 {
2660         int                     error;
2661         xfs_mount_t             *mp;
2662         xfs_efi_log_item_t      *efip;
2663         xfs_efi_log_format_t    *efi_formatp;
2664
2665         if (pass == XLOG_RECOVER_PASS1) {
2666                 return 0;
2667         }
2668
2669         efi_formatp = (xfs_efi_log_format_t *)item->ri_buf[0].i_addr;
2670
2671         mp = log->l_mp;
2672         efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
2673         if ((error = xfs_efi_copy_format(&(item->ri_buf[0]),
2674                                          &(efip->efi_format)))) {
2675                 xfs_efi_item_free(efip);
2676                 return error;
2677         }
2678         efip->efi_next_extent = efi_formatp->efi_nextents;
2679         efip->efi_flags |= XFS_EFI_COMMITTED;
2680
2681         spin_lock(&log->l_ailp->xa_lock);
2682         /*
2683          * xfs_trans_ail_update() drops the AIL lock.
2684          */
2685         xfs_trans_ail_update(log->l_ailp, (xfs_log_item_t *)efip, lsn);
2686         return 0;
2687 }
2688
2689
2690 /*
2691  * This routine is called when an efd format structure is found in
2692  * a committed transaction in the log.  It's purpose is to cancel
2693  * the corresponding efi if it was still in the log.  To do this
2694  * it searches the AIL for the efi with an id equal to that in the
2695  * efd format structure.  If we find it, we remove the efi from the
2696  * AIL and free it.
2697  */
2698 STATIC void
2699 xlog_recover_do_efd_trans(
2700         xlog_t                  *log,
2701         xlog_recover_item_t     *item,
2702         int                     pass)
2703 {
2704         xfs_efd_log_format_t    *efd_formatp;
2705         xfs_efi_log_item_t      *efip = NULL;
2706         xfs_log_item_t          *lip;
2707         __uint64_t              efi_id;
2708         struct xfs_ail_cursor   cur;
2709         struct xfs_ail          *ailp = log->l_ailp;
2710
2711         if (pass == XLOG_RECOVER_PASS1) {
2712                 return;
2713         }
2714
2715         efd_formatp = (xfs_efd_log_format_t *)item->ri_buf[0].i_addr;
2716         ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) +
2717                 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) ||
2718                (item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) +
2719                 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t)))));
2720         efi_id = efd_formatp->efd_efi_id;
2721
2722         /*
2723          * Search for the efi with the id in the efd format structure
2724          * in the AIL.
2725          */
2726         spin_lock(&ailp->xa_lock);
2727         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
2728         while (lip != NULL) {
2729                 if (lip->li_type == XFS_LI_EFI) {
2730                         efip = (xfs_efi_log_item_t *)lip;
2731                         if (efip->efi_format.efi_id == efi_id) {
2732                                 /*
2733                                  * xfs_trans_ail_delete() drops the
2734                                  * AIL lock.
2735                                  */
2736                                 xfs_trans_ail_delete(ailp, lip);
2737                                 xfs_efi_item_free(efip);
2738                                 spin_lock(&ailp->xa_lock);
2739                                 break;
2740                         }
2741                 }
2742                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
2743         }
2744         xfs_trans_ail_cursor_done(ailp, &cur);
2745         spin_unlock(&ailp->xa_lock);
2746 }
2747
2748 /*
2749  * Perform the transaction
2750  *
2751  * If the transaction modifies a buffer or inode, do it now.  Otherwise,
2752  * EFIs and EFDs get queued up by adding entries into the AIL for them.
2753  */
2754 STATIC int
2755 xlog_recover_do_trans(
2756         xlog_t                  *log,
2757         xlog_recover_t          *trans,
2758         int                     pass)
2759 {
2760         int                     error = 0;
2761         xlog_recover_item_t     *item, *first_item;
2762
2763         if ((error = xlog_recover_reorder_trans(trans)))
2764                 return error;
2765         first_item = item = trans->r_itemq;
2766         do {
2767                 /*
2768                  * we don't need to worry about the block number being
2769                  * truncated in > 1 TB buffers because in user-land,
2770                  * we're now n32 or 64-bit so xfs_daddr_t is 64-bits so
2771                  * the blknos will get through the user-mode buffer
2772                  * cache properly.  The only bad case is o32 kernels
2773                  * where xfs_daddr_t is 32-bits but mount will warn us
2774                  * off a > 1 TB filesystem before we get here.
2775                  */
2776                 if ((ITEM_TYPE(item) == XFS_LI_BUF)) {
2777                         if  ((error = xlog_recover_do_buffer_trans(log, item,
2778                                                                  pass)))
2779                                 break;
2780                 } else if ((ITEM_TYPE(item) == XFS_LI_INODE)) {
2781                         if ((error = xlog_recover_do_inode_trans(log, item,
2782                                                                 pass)))
2783                                 break;
2784                 } else if (ITEM_TYPE(item) == XFS_LI_EFI) {
2785                         if ((error = xlog_recover_do_efi_trans(log, item, trans->r_lsn,
2786                                                   pass)))
2787                                 break;
2788                 } else if (ITEM_TYPE(item) == XFS_LI_EFD) {
2789                         xlog_recover_do_efd_trans(log, item, pass);
2790                 } else if (ITEM_TYPE(item) == XFS_LI_DQUOT) {
2791                         if ((error = xlog_recover_do_dquot_trans(log, item,
2792                                                                    pass)))
2793                                         break;
2794                 } else if ((ITEM_TYPE(item) == XFS_LI_QUOTAOFF)) {
2795                         if ((error = xlog_recover_do_quotaoff_trans(log, item,
2796                                                                    pass)))
2797                                         break;
2798                 } else {
2799                         xlog_warn("XFS: xlog_recover_do_trans");
2800                         ASSERT(0);
2801                         error = XFS_ERROR(EIO);
2802                         break;
2803                 }
2804                 item = item->ri_next;
2805         } while (first_item != item);
2806
2807         return error;
2808 }
2809
2810 /*
2811  * Free up any resources allocated by the transaction
2812  *
2813  * Remember that EFIs, EFDs, and IUNLINKs are handled later.
2814  */
2815 STATIC void
2816 xlog_recover_free_trans(
2817         xlog_recover_t          *trans)
2818 {
2819         xlog_recover_item_t     *first_item, *item, *free_item;
2820         int                     i;
2821
2822         item = first_item = trans->r_itemq;
2823         do {
2824                 free_item = item;
2825                 item = item->ri_next;
2826                  /* Free the regions in the item. */
2827                 for (i = 0; i < free_item->ri_cnt; i++) {
2828                         kmem_free(free_item->ri_buf[i].i_addr);
2829                 }
2830                 /* Free the item itself */
2831                 kmem_free(free_item->ri_buf);
2832                 kmem_free(free_item);
2833         } while (first_item != item);
2834         /* Free the transaction recover structure */
2835         kmem_free(trans);
2836 }
2837
2838 STATIC int
2839 xlog_recover_commit_trans(
2840         xlog_t                  *log,
2841         xlog_recover_t          **q,
2842         xlog_recover_t          *trans,
2843         int                     pass)
2844 {
2845         int                     error;
2846
2847         if ((error = xlog_recover_unlink_tid(q, trans)))
2848                 return error;
2849         if ((error = xlog_recover_do_trans(log, trans, pass)))
2850                 return error;
2851         xlog_recover_free_trans(trans);                 /* no error */
2852         return 0;
2853 }
2854
2855 STATIC int
2856 xlog_recover_unmount_trans(
2857         xlog_recover_t          *trans)
2858 {
2859         /* Do nothing now */
2860         xlog_warn("XFS: xlog_recover_unmount_trans: Unmount LR");
2861         return 0;
2862 }
2863
2864 /*
2865  * There are two valid states of the r_state field.  0 indicates that the
2866  * transaction structure is in a normal state.  We have either seen the
2867  * start of the transaction or the last operation we added was not a partial
2868  * operation.  If the last operation we added to the transaction was a
2869  * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
2870  *
2871  * NOTE: skip LRs with 0 data length.
2872  */
2873 STATIC int
2874 xlog_recover_process_data(
2875         xlog_t                  *log,
2876         xlog_recover_t          *rhash[],
2877         xlog_rec_header_t       *rhead,
2878         xfs_caddr_t             dp,
2879         int                     pass)
2880 {
2881         xfs_caddr_t             lp;
2882         int                     num_logops;
2883         xlog_op_header_t        *ohead;
2884         xlog_recover_t          *trans;
2885         xlog_tid_t              tid;
2886         int                     error;
2887         unsigned long           hash;
2888         uint                    flags;
2889
2890         lp = dp + be32_to_cpu(rhead->h_len);
2891         num_logops = be32_to_cpu(rhead->h_num_logops);
2892
2893         /* check the log format matches our own - else we can't recover */
2894         if (xlog_header_check_recover(log->l_mp, rhead))
2895                 return (XFS_ERROR(EIO));
2896
2897         while ((dp < lp) && num_logops) {
2898                 ASSERT(dp + sizeof(xlog_op_header_t) <= lp);
2899                 ohead = (xlog_op_header_t *)dp;
2900                 dp += sizeof(xlog_op_header_t);
2901                 if (ohead->oh_clientid != XFS_TRANSACTION &&
2902                     ohead->oh_clientid != XFS_LOG) {
2903                         xlog_warn(
2904                 "XFS: xlog_recover_process_data: bad clientid");
2905                         ASSERT(0);
2906                         return (XFS_ERROR(EIO));
2907                 }
2908                 tid = be32_to_cpu(ohead->oh_tid);
2909                 hash = XLOG_RHASH(tid);
2910                 trans = xlog_recover_find_tid(rhash[hash], tid);
2911                 if (trans == NULL) {               /* not found; add new tid */
2912                         if (ohead->oh_flags & XLOG_START_TRANS)
2913                                 xlog_recover_new_tid(&rhash[hash], tid,
2914                                         be64_to_cpu(rhead->h_lsn));
2915                 } else {
2916                         if (dp + be32_to_cpu(ohead->oh_len) > lp) {
2917                                 xlog_warn(
2918                         "XFS: xlog_recover_process_data: bad length");
2919                                 WARN_ON(1);
2920                                 return (XFS_ERROR(EIO));
2921                         }
2922                         flags = ohead->oh_flags & ~XLOG_END_TRANS;
2923                         if (flags & XLOG_WAS_CONT_TRANS)
2924                                 flags &= ~XLOG_CONTINUE_TRANS;
2925                         switch (flags) {
2926                         case XLOG_COMMIT_TRANS:
2927                                 error = xlog_recover_commit_trans(log,
2928                                                 &rhash[hash], trans, pass);
2929                                 break;
2930                         case XLOG_UNMOUNT_TRANS:
2931                                 error = xlog_recover_unmount_trans(trans);
2932                                 break;
2933                         case XLOG_WAS_CONT_TRANS:
2934                                 error = xlog_recover_add_to_cont_trans(trans,
2935                                                 dp, be32_to_cpu(ohead->oh_len));
2936                                 break;
2937                         case XLOG_START_TRANS:
2938                                 xlog_warn(
2939                         "XFS: xlog_recover_process_data: bad transaction");
2940                                 ASSERT(0);
2941                                 error = XFS_ERROR(EIO);
2942                                 break;
2943                         case 0:
2944                         case XLOG_CONTINUE_TRANS:
2945                                 error = xlog_recover_add_to_trans(trans,
2946                                                 dp, be32_to_cpu(ohead->oh_len));
2947                                 break;
2948                         default:
2949                                 xlog_warn(
2950                         "XFS: xlog_recover_process_data: bad flag");
2951                                 ASSERT(0);
2952                                 error = XFS_ERROR(EIO);
2953                                 break;
2954                         }
2955                         if (error)
2956                                 return error;
2957                 }
2958                 dp += be32_to_cpu(ohead->oh_len);
2959                 num_logops--;
2960         }
2961         return 0;
2962 }
2963
2964 /*
2965  * Process an extent free intent item that was recovered from
2966  * the log.  We need to free the extents that it describes.
2967  */
2968 STATIC int
2969 xlog_recover_process_efi(
2970         xfs_mount_t             *mp,
2971         xfs_efi_log_item_t      *efip)
2972 {
2973         xfs_efd_log_item_t      *efdp;
2974         xfs_trans_t             *tp;
2975         int                     i;
2976         int                     error = 0;
2977         xfs_extent_t            *extp;
2978         xfs_fsblock_t           startblock_fsb;
2979
2980         ASSERT(!(efip->efi_flags & XFS_EFI_RECOVERED));
2981
2982         /*
2983          * First check the validity of the extents described by the
2984          * EFI.  If any are bad, then assume that all are bad and
2985          * just toss the EFI.
2986          */
2987         for (i = 0; i < efip->efi_format.efi_nextents; i++) {
2988                 extp = &(efip->efi_format.efi_extents[i]);
2989                 startblock_fsb = XFS_BB_TO_FSB(mp,
2990                                    XFS_FSB_TO_DADDR(mp, extp->ext_start));
2991                 if ((startblock_fsb == 0) ||
2992                     (extp->ext_len == 0) ||
2993                     (startblock_fsb >= mp->m_sb.sb_dblocks) ||
2994                     (extp->ext_len >= mp->m_sb.sb_agblocks)) {
2995                         /*
2996                          * This will pull the EFI from the AIL and
2997                          * free the memory associated with it.
2998                          */
2999                         xfs_efi_release(efip, efip->efi_format.efi_nextents);
3000                         return XFS_ERROR(EIO);
3001                 }
3002         }
3003
3004         tp = xfs_trans_alloc(mp, 0);
3005         error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0, 0, 0);
3006         if (error)
3007                 goto abort_error;
3008         efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
3009
3010         for (i = 0; i < efip->efi_format.efi_nextents; i++) {
3011                 extp = &(efip->efi_format.efi_extents[i]);
3012                 error = xfs_free_extent(tp, extp->ext_start, extp->ext_len);
3013                 if (error)
3014                         goto abort_error;
3015                 xfs_trans_log_efd_extent(tp, efdp, extp->ext_start,
3016                                          extp->ext_len);
3017         }
3018
3019         efip->efi_flags |= XFS_EFI_RECOVERED;
3020         error = xfs_trans_commit(tp, 0);
3021         return error;
3022
3023 abort_error:
3024         xfs_trans_cancel(tp, XFS_TRANS_ABORT);
3025         return error;
3026 }
3027
3028 /*
3029  * When this is called, all of the EFIs which did not have
3030  * corresponding EFDs should be in the AIL.  What we do now
3031  * is free the extents associated with each one.
3032  *
3033  * Since we process the EFIs in normal transactions, they
3034  * will be removed at some point after the commit.  This prevents
3035  * us from just walking down the list processing each one.
3036  * We'll use a flag in the EFI to skip those that we've already
3037  * processed and use the AIL iteration mechanism's generation
3038  * count to try to speed this up at least a bit.
3039  *
3040  * When we start, we know that the EFIs are the only things in
3041  * the AIL.  As we process them, however, other items are added
3042  * to the AIL.  Since everything added to the AIL must come after
3043  * everything already in the AIL, we stop processing as soon as
3044  * we see something other than an EFI in the AIL.
3045  */
3046 STATIC int
3047 xlog_recover_process_efis(
3048         xlog_t                  *log)
3049 {
3050         xfs_log_item_t          *lip;
3051         xfs_efi_log_item_t      *efip;
3052         int                     error = 0;
3053         struct xfs_ail_cursor   cur;
3054         struct xfs_ail          *ailp;
3055
3056         ailp = log->l_ailp;
3057         spin_lock(&ailp->xa_lock);
3058         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
3059         while (lip != NULL) {
3060                 /*
3061                  * We're done when we see something other than an EFI.
3062                  * There should be no EFIs left in the AIL now.
3063                  */
3064                 if (lip->li_type != XFS_LI_EFI) {
3065 #ifdef DEBUG
3066                         for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
3067                                 ASSERT(lip->li_type != XFS_LI_EFI);
3068 #endif
3069                         break;
3070                 }
3071
3072                 /*
3073                  * Skip EFIs that we've already processed.
3074                  */
3075                 efip = (xfs_efi_log_item_t *)lip;
3076                 if (efip->efi_flags & XFS_EFI_RECOVERED) {
3077                         lip = xfs_trans_ail_cursor_next(ailp, &cur);
3078                         continue;
3079                 }
3080
3081                 spin_unlock(&ailp->xa_lock);
3082                 error = xlog_recover_process_efi(log->l_mp, efip);
3083                 spin_lock(&ailp->xa_lock);
3084                 if (error)
3085                         goto out;
3086                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
3087         }
3088 out:
3089         xfs_trans_ail_cursor_done(ailp, &cur);
3090         spin_unlock(&ailp->xa_lock);
3091         return error;
3092 }
3093
3094 /*
3095  * This routine performs a transaction to null out a bad inode pointer
3096  * in an agi unlinked inode hash bucket.
3097  */
3098 STATIC void
3099 xlog_recover_clear_agi_bucket(
3100         xfs_mount_t     *mp,
3101         xfs_agnumber_t  agno,
3102         int             bucket)
3103 {
3104         xfs_trans_t     *tp;
3105         xfs_agi_t       *agi;
3106         xfs_buf_t       *agibp;
3107         int             offset;
3108         int             error;
3109
3110         tp = xfs_trans_alloc(mp, XFS_TRANS_CLEAR_AGI_BUCKET);
3111         error = xfs_trans_reserve(tp, 0, XFS_CLEAR_AGI_BUCKET_LOG_RES(mp),
3112                                   0, 0, 0);
3113         if (error)
3114                 goto out_abort;
3115
3116         error = xfs_read_agi(mp, tp, agno, &agibp);
3117         if (error)
3118                 goto out_abort;
3119
3120         agi = XFS_BUF_TO_AGI(agibp);
3121         agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
3122         offset = offsetof(xfs_agi_t, agi_unlinked) +
3123                  (sizeof(xfs_agino_t) * bucket);
3124         xfs_trans_log_buf(tp, agibp, offset,
3125                           (offset + sizeof(xfs_agino_t) - 1));
3126
3127         error = xfs_trans_commit(tp, 0);
3128         if (error)
3129                 goto out_error;
3130         return;
3131
3132 out_abort:
3133         xfs_trans_cancel(tp, XFS_TRANS_ABORT);
3134 out_error:
3135         xfs_fs_cmn_err(CE_WARN, mp, "xlog_recover_clear_agi_bucket: "
3136                         "failed to clear agi %d. Continuing.", agno);
3137         return;
3138 }
3139
3140 STATIC xfs_agino_t
3141 xlog_recover_process_one_iunlink(
3142         struct xfs_mount                *mp,
3143         xfs_agnumber_t                  agno,
3144         xfs_agino_t                     agino,
3145         int                             bucket)
3146 {
3147         struct xfs_buf                  *ibp;
3148         struct xfs_dinode               *dip;
3149         struct xfs_inode                *ip;
3150         xfs_ino_t                       ino;
3151         int                             error;
3152
3153         ino = XFS_AGINO_TO_INO(mp, agno, agino);
3154         error = xfs_iget(mp, NULL, ino, 0, 0, &ip, 0);
3155         if (error)
3156                 goto fail;
3157
3158         /*
3159          * Get the on disk inode to find the next inode in the bucket.
3160          */
3161         error = xfs_itobp(mp, NULL, ip, &dip, &ibp, XFS_BUF_LOCK);
3162         if (error)
3163                 goto fail_iput;
3164
3165         ASSERT(ip->i_d.di_nlink == 0);
3166         ASSERT(ip->i_d.di_mode != 0);
3167
3168         /* setup for the next pass */
3169         agino = be32_to_cpu(dip->di_next_unlinked);
3170         xfs_buf_relse(ibp);
3171
3172         /*
3173          * Prevent any DMAPI event from being sent when the reference on
3174          * the inode is dropped.
3175          */
3176         ip->i_d.di_dmevmask = 0;
3177
3178         IRELE(ip);
3179         return agino;
3180
3181  fail_iput:
3182         IRELE(ip);
3183  fail:
3184         /*
3185          * We can't read in the inode this bucket points to, or this inode
3186          * is messed up.  Just ditch this bucket of inodes.  We will lose
3187          * some inodes and space, but at least we won't hang.
3188          *
3189          * Call xlog_recover_clear_agi_bucket() to perform a transaction to
3190          * clear the inode pointer in the bucket.
3191          */
3192         xlog_recover_clear_agi_bucket(mp, agno, bucket);
3193         return NULLAGINO;
3194 }
3195
3196 /*
3197  * xlog_iunlink_recover
3198  *
3199  * This is called during recovery to process any inodes which
3200  * we unlinked but not freed when the system crashed.  These
3201  * inodes will be on the lists in the AGI blocks.  What we do
3202  * here is scan all the AGIs and fully truncate and free any
3203  * inodes found on the lists.  Each inode is removed from the
3204  * lists when it has been fully truncated and is freed.  The
3205  * freeing of the inode and its removal from the list must be
3206  * atomic.
3207  */
3208 void
3209 xlog_recover_process_iunlinks(
3210         xlog_t          *log)
3211 {
3212         xfs_mount_t     *mp;
3213         xfs_agnumber_t  agno;
3214         xfs_agi_t       *agi;
3215         xfs_buf_t       *agibp;
3216         xfs_agino_t     agino;
3217         int             bucket;
3218         int             error;
3219         uint            mp_dmevmask;
3220
3221         mp = log->l_mp;
3222
3223         /*
3224          * Prevent any DMAPI event from being sent while in this function.
3225          */
3226         mp_dmevmask = mp->m_dmevmask;
3227         mp->m_dmevmask = 0;
3228
3229         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
3230                 /*
3231                  * Find the agi for this ag.
3232                  */
3233                 error = xfs_read_agi(mp, NULL, agno, &agibp);
3234                 if (error) {
3235                         /*
3236                          * AGI is b0rked. Don't process it.
3237                          *
3238                          * We should probably mark the filesystem as corrupt
3239                          * after we've recovered all the ag's we can....
3240                          */
3241                         continue;
3242                 }
3243                 agi = XFS_BUF_TO_AGI(agibp);
3244
3245                 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) {
3246                         agino = be32_to_cpu(agi->agi_unlinked[bucket]);
3247                         while (agino != NULLAGINO) {
3248                                 /*
3249                                  * Release the agi buffer so that it can
3250                                  * be acquired in the normal course of the
3251                                  * transaction to truncate and free the inode.
3252                                  */
3253                                 xfs_buf_relse(agibp);
3254
3255                                 agino = xlog_recover_process_one_iunlink(mp,
3256                                                         agno, agino, bucket);
3257
3258                                 /*
3259                                  * Reacquire the agibuffer and continue around
3260                                  * the loop. This should never fail as we know
3261                                  * the buffer was good earlier on.
3262                                  */
3263                                 error = xfs_read_agi(mp, NULL, agno, &agibp);
3264                                 ASSERT(error == 0);
3265                                 agi = XFS_BUF_TO_AGI(agibp);
3266                         }
3267                 }
3268
3269                 /*
3270                  * Release the buffer for the current agi so we can
3271                  * go on to the next one.
3272                  */
3273                 xfs_buf_relse(agibp);
3274         }
3275
3276         mp->m_dmevmask = mp_dmevmask;
3277 }
3278
3279
3280 #ifdef DEBUG
3281 STATIC void
3282 xlog_pack_data_checksum(
3283         xlog_t          *log,
3284         xlog_in_core_t  *iclog,
3285         int             size)
3286 {
3287         int             i;
3288         __be32          *up;
3289         uint            chksum = 0;
3290
3291         up = (__be32 *)iclog->ic_datap;
3292         /* divide length by 4 to get # words */
3293         for (i = 0; i < (size >> 2); i++) {
3294                 chksum ^= be32_to_cpu(*up);
3295                 up++;
3296         }
3297         iclog->ic_header.h_chksum = cpu_to_be32(chksum);
3298 }
3299 #else
3300 #define xlog_pack_data_checksum(log, iclog, size)
3301 #endif
3302
3303 /*
3304  * Stamp cycle number in every block
3305  */
3306 void
3307 xlog_pack_data(
3308         xlog_t                  *log,
3309         xlog_in_core_t          *iclog,
3310         int                     roundoff)
3311 {
3312         int                     i, j, k;
3313         int                     size = iclog->ic_offset + roundoff;
3314         __be32                  cycle_lsn;
3315         xfs_caddr_t             dp;
3316
3317         xlog_pack_data_checksum(log, iclog, size);
3318
3319         cycle_lsn = CYCLE_LSN_DISK(iclog->ic_header.h_lsn);
3320
3321         dp = iclog->ic_datap;
3322         for (i = 0; i < BTOBB(size) &&
3323                 i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
3324                 iclog->ic_header.h_cycle_data[i] = *(__be32 *)dp;
3325                 *(__be32 *)dp = cycle_lsn;
3326                 dp += BBSIZE;
3327         }
3328
3329         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
3330                 xlog_in_core_2_t *xhdr = iclog->ic_data;
3331
3332                 for ( ; i < BTOBB(size); i++) {
3333                         j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3334                         k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3335                         xhdr[j].hic_xheader.xh_cycle_data[k] = *(__be32 *)dp;
3336                         *(__be32 *)dp = cycle_lsn;
3337                         dp += BBSIZE;
3338                 }
3339
3340                 for (i = 1; i < log->l_iclog_heads; i++) {
3341                         xhdr[i].hic_xheader.xh_cycle = cycle_lsn;
3342                 }
3343         }
3344 }
3345
3346 #if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
3347 STATIC void
3348 xlog_unpack_data_checksum(
3349         xlog_rec_header_t       *rhead,
3350         xfs_caddr_t             dp,
3351         xlog_t                  *log)
3352 {
3353         __be32                  *up = (__be32 *)dp;
3354         uint                    chksum = 0;
3355         int                     i;
3356
3357         /* divide length by 4 to get # words */
3358         for (i=0; i < be32_to_cpu(rhead->h_len) >> 2; i++) {
3359                 chksum ^= be32_to_cpu(*up);
3360                 up++;
3361         }
3362         if (chksum != be32_to_cpu(rhead->h_chksum)) {
3363             if (rhead->h_chksum ||
3364                 ((log->l_flags & XLOG_CHKSUM_MISMATCH) == 0)) {
3365                     cmn_err(CE_DEBUG,
3366                         "XFS: LogR chksum mismatch: was (0x%x) is (0x%x)\n",
3367                             be32_to_cpu(rhead->h_chksum), chksum);
3368                     cmn_err(CE_DEBUG,
3369 "XFS: Disregard message if filesystem was created with non-DEBUG kernel");
3370                     if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
3371                             cmn_err(CE_DEBUG,
3372                                 "XFS: LogR this is a LogV2 filesystem\n");
3373                     }
3374                     log->l_flags |= XLOG_CHKSUM_MISMATCH;
3375             }
3376         }
3377 }
3378 #else
3379 #define xlog_unpack_data_checksum(rhead, dp, log)
3380 #endif
3381
3382 STATIC void
3383 xlog_unpack_data(
3384         xlog_rec_header_t       *rhead,
3385         xfs_caddr_t             dp,
3386         xlog_t                  *log)
3387 {
3388         int                     i, j, k;
3389
3390         for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) &&
3391                   i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
3392                 *(__be32 *)dp = *(__be32 *)&rhead->h_cycle_data[i];
3393                 dp += BBSIZE;
3394         }
3395
3396         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
3397                 xlog_in_core_2_t *xhdr = (xlog_in_core_2_t *)rhead;
3398                 for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
3399                         j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3400                         k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3401                         *(__be32 *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];
3402                         dp += BBSIZE;
3403                 }
3404         }
3405
3406         xlog_unpack_data_checksum(rhead, dp, log);
3407 }
3408
3409 STATIC int
3410 xlog_valid_rec_header(
3411         xlog_t                  *log,
3412         xlog_rec_header_t       *rhead,
3413         xfs_daddr_t             blkno)
3414 {
3415         int                     hlen;
3416
3417         if (unlikely(be32_to_cpu(rhead->h_magicno) != XLOG_HEADER_MAGIC_NUM)) {
3418                 XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
3419                                 XFS_ERRLEVEL_LOW, log->l_mp);
3420                 return XFS_ERROR(EFSCORRUPTED);
3421         }
3422         if (unlikely(
3423             (!rhead->h_version ||
3424             (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
3425                 xlog_warn("XFS: %s: unrecognised log version (%d).",
3426                         __func__, be32_to_cpu(rhead->h_version));
3427                 return XFS_ERROR(EIO);
3428         }
3429
3430         /* LR body must have data or it wouldn't have been written */
3431         hlen = be32_to_cpu(rhead->h_len);
3432         if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
3433                 XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
3434                                 XFS_ERRLEVEL_LOW, log->l_mp);
3435                 return XFS_ERROR(EFSCORRUPTED);
3436         }
3437         if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
3438                 XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
3439                                 XFS_ERRLEVEL_LOW, log->l_mp);
3440                 return XFS_ERROR(EFSCORRUPTED);
3441         }
3442         return 0;
3443 }
3444
3445 /*
3446  * Read the log from tail to head and process the log records found.
3447  * Handle the two cases where the tail and head are in the same cycle
3448  * and where the active portion of the log wraps around the end of
3449  * the physical log separately.  The pass parameter is passed through
3450  * to the routines called to process the data and is not looked at
3451  * here.
3452  */
3453 STATIC int
3454 xlog_do_recovery_pass(
3455         xlog_t                  *log,
3456         xfs_daddr_t             head_blk,
3457         xfs_daddr_t             tail_blk,
3458         int                     pass)
3459 {
3460         xlog_rec_header_t       *rhead;
3461         xfs_daddr_t             blk_no;
3462         xfs_caddr_t             bufaddr, offset;
3463         xfs_buf_t               *hbp, *dbp;
3464         int                     error = 0, h_size;
3465         int                     bblks, split_bblks;
3466         int                     hblks, split_hblks, wrapped_hblks;
3467         xlog_recover_t          *rhash[XLOG_RHASH_SIZE];
3468
3469         ASSERT(head_blk != tail_blk);
3470
3471         /*
3472          * Read the header of the tail block and get the iclog buffer size from
3473          * h_size.  Use this to tell how many sectors make up the log header.
3474          */
3475         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
3476                 /*
3477                  * When using variable length iclogs, read first sector of
3478                  * iclog header and extract the header size from it.  Get a
3479                  * new hbp that is the correct size.
3480                  */
3481                 hbp = xlog_get_bp(log, 1);
3482                 if (!hbp)
3483                         return ENOMEM;
3484                 if ((error = xlog_bread(log, tail_blk, 1, hbp)))
3485                         goto bread_err1;
3486                 offset = xlog_align(log, tail_blk, 1, hbp);
3487                 rhead = (xlog_rec_header_t *)offset;
3488                 error = xlog_valid_rec_header(log, rhead, tail_blk);
3489                 if (error)
3490                         goto bread_err1;
3491                 h_size = be32_to_cpu(rhead->h_size);
3492                 if ((be32_to_cpu(rhead->h_version) & XLOG_VERSION_2) &&
3493                     (h_size > XLOG_HEADER_CYCLE_SIZE)) {
3494                         hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
3495                         if (h_size % XLOG_HEADER_CYCLE_SIZE)
3496                                 hblks++;
3497                         xlog_put_bp(hbp);
3498                         hbp = xlog_get_bp(log, hblks);
3499                 } else {
3500                         hblks = 1;
3501                 }
3502         } else {
3503                 ASSERT(log->l_sectbb_log == 0);
3504                 hblks = 1;
3505                 hbp = xlog_get_bp(log, 1);
3506                 h_size = XLOG_BIG_RECORD_BSIZE;
3507         }
3508
3509         if (!hbp)
3510                 return ENOMEM;
3511         dbp = xlog_get_bp(log, BTOBB(h_size));
3512         if (!dbp) {
3513                 xlog_put_bp(hbp);
3514                 return ENOMEM;
3515         }
3516
3517         memset(rhash, 0, sizeof(rhash));
3518         if (tail_blk <= head_blk) {
3519                 for (blk_no = tail_blk; blk_no < head_blk; ) {
3520                         if ((error = xlog_bread(log, blk_no, hblks, hbp)))
3521                                 goto bread_err2;
3522                         offset = xlog_align(log, blk_no, hblks, hbp);
3523                         rhead = (xlog_rec_header_t *)offset;
3524                         error = xlog_valid_rec_header(log, rhead, blk_no);
3525                         if (error)
3526                                 goto bread_err2;
3527
3528                         /* blocks in data section */
3529                         bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
3530                         error = xlog_bread(log, blk_no + hblks, bblks, dbp);
3531                         if (error)
3532                                 goto bread_err2;
3533                         offset = xlog_align(log, blk_no + hblks, bblks, dbp);
3534                         xlog_unpack_data(rhead, offset, log);
3535                         if ((error = xlog_recover_process_data(log,
3536                                                 rhash, rhead, offset, pass)))
3537                                 goto bread_err2;
3538                         blk_no += bblks + hblks;
3539                 }
3540         } else {
3541                 /*
3542                  * Perform recovery around the end of the physical log.
3543                  * When the head is not on the same cycle number as the tail,
3544                  * we can't do a sequential recovery as above.
3545                  */
3546                 blk_no = tail_blk;
3547                 while (blk_no < log->l_logBBsize) {
3548                         /*
3549                          * Check for header wrapping around physical end-of-log
3550                          */
3551                         offset = NULL;
3552                         split_hblks = 0;
3553                         wrapped_hblks = 0;
3554                         if (blk_no + hblks <= log->l_logBBsize) {
3555                                 /* Read header in one read */
3556                                 error = xlog_bread(log, blk_no, hblks, hbp);
3557                                 if (error)
3558                                         goto bread_err2;
3559                                 offset = xlog_align(log, blk_no, hblks, hbp);
3560                         } else {
3561                                 /* This LR is split across physical log end */
3562                                 if (blk_no != log->l_logBBsize) {
3563                                         /* some data before physical log end */
3564                                         ASSERT(blk_no <= INT_MAX);
3565                                         split_hblks = log->l_logBBsize - (int)blk_no;
3566                                         ASSERT(split_hblks > 0);
3567                                         if ((error = xlog_bread(log, blk_no,
3568                                                         split_hblks, hbp)))
3569                                                 goto bread_err2;
3570                                         offset = xlog_align(log, blk_no,
3571                                                         split_hblks, hbp);
3572                                 }
3573                                 /*
3574                                  * Note: this black magic still works with
3575                                  * large sector sizes (non-512) only because:
3576                                  * - we increased the buffer size originally
3577                                  *   by 1 sector giving us enough extra space
3578                                  *   for the second read;
3579                                  * - the log start is guaranteed to be sector
3580                                  *   aligned;
3581                                  * - we read the log end (LR header start)
3582                                  *   _first_, then the log start (LR header end)
3583                                  *   - order is important.
3584                                  */
3585                                 wrapped_hblks = hblks - split_hblks;
3586                                 bufaddr = XFS_BUF_PTR(hbp);
3587                                 error = XFS_BUF_SET_PTR(hbp,
3588                                                 bufaddr + BBTOB(split_hblks),
3589                                                 BBTOB(hblks - split_hblks));
3590                                 if (!error)
3591                                         error = xlog_bread(log, 0,
3592                                                         wrapped_hblks, hbp);
3593                                 if (!error)
3594                                         error = XFS_BUF_SET_PTR(hbp, bufaddr,
3595                                                         BBTOB(hblks));
3596                                 if (error)
3597                                         goto bread_err2;
3598                                 if (!offset)
3599                                         offset = xlog_align(log, 0,
3600                                                         wrapped_hblks, hbp);
3601                         }
3602                         rhead = (xlog_rec_header_t *)offset;
3603                         error = xlog_valid_rec_header(log, rhead,
3604                                                 split_hblks ? blk_no : 0);
3605                         if (error)
3606                                 goto bread_err2;
3607
3608                         bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
3609                         blk_no += hblks;
3610
3611                         /* Read in data for log record */
3612                         if (blk_no + bblks <= log->l_logBBsize) {
3613                                 error = xlog_bread(log, blk_no, bblks, dbp);
3614                                 if (error)
3615                                         goto bread_err2;
3616                                 offset = xlog_align(log, blk_no, bblks, dbp);
3617                         } else {
3618                                 /* This log record is split across the
3619                                  * physical end of log */
3620                                 offset = NULL;
3621                                 split_bblks = 0;
3622                                 if (blk_no != log->l_logBBsize) {
3623                                         /* some data is before the physical
3624                                          * end of log */
3625                                         ASSERT(!wrapped_hblks);
3626                                         ASSERT(blk_no <= INT_MAX);
3627                                         split_bblks =
3628                                                 log->l_logBBsize - (int)blk_no;
3629                                         ASSERT(split_bblks > 0);
3630                                         if ((error = xlog_bread(log, blk_no,
3631                                                         split_bblks, dbp)))
3632                                                 goto bread_err2;
3633                                         offset = xlog_align(log, blk_no,
3634                                                         split_bblks, dbp);
3635                                 }
3636                                 /*
3637                                  * Note: this black magic still works with
3638                                  * large sector sizes (non-512) only because:
3639                                  * - we increased the buffer size originally
3640                                  *   by 1 sector giving us enough extra space
3641                                  *   for the second read;
3642                                  * - the log start is guaranteed to be sector
3643                                  *   aligned;
3644                                  * - we read the log end (LR header start)
3645                                  *   _first_, then the log start (LR header end)
3646                                  *   - order is important.
3647                                  */
3648                                 bufaddr = XFS_BUF_PTR(dbp);
3649                                 error = XFS_BUF_SET_PTR(dbp,
3650                                                 bufaddr + BBTOB(split_bblks),
3651                                                 BBTOB(bblks - split_bblks));
3652                                 if (!error)
3653                                         error = xlog_bread(log, wrapped_hblks,
3654                                                         bblks - split_bblks,
3655                                                         dbp);
3656                                 if (!error)
3657                                         error = XFS_BUF_SET_PTR(dbp, bufaddr,
3658                                                         h_size);
3659                                 if (error)
3660                                         goto bread_err2;
3661                                 if (!offset)
3662                                         offset = xlog_align(log, wrapped_hblks,
3663                                                 bblks - split_bblks, dbp);
3664                         }
3665                         xlog_unpack_data(rhead, offset, log);
3666                         if ((error = xlog_recover_process_data(log, rhash,
3667                                                         rhead, offset, pass)))
3668                                 goto bread_err2;
3669                         blk_no += bblks;
3670                 }
3671
3672                 ASSERT(blk_no >= log->l_logBBsize);
3673                 blk_no -= log->l_logBBsize;
3674
3675                 /* read first part of physical log */
3676                 while (blk_no < head_blk) {
3677                         if ((error = xlog_bread(log, blk_no, hblks, hbp)))
3678                                 goto bread_err2;
3679                         offset = xlog_align(log, blk_no, hblks, hbp);
3680                         rhead = (xlog_rec_header_t *)offset;
3681                         error = xlog_valid_rec_header(log, rhead, blk_no);
3682                         if (error)
3683                                 goto bread_err2;
3684                         bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
3685                         if ((error = xlog_bread(log, blk_no+hblks, bblks, dbp)))
3686                                 goto bread_err2;
3687                         offset = xlog_align(log, blk_no+hblks, bblks, dbp);
3688                         xlog_unpack_data(rhead, offset, log);
3689                         if ((error = xlog_recover_process_data(log, rhash,
3690                                                         rhead, offset, pass)))
3691                                 goto bread_err2;
3692                         blk_no += bblks + hblks;
3693                 }
3694         }
3695
3696  bread_err2:
3697         xlog_put_bp(dbp);
3698  bread_err1:
3699         xlog_put_bp(hbp);
3700         return error;
3701 }
3702
3703 /*
3704  * Do the recovery of the log.  We actually do this in two phases.
3705  * The two passes are necessary in order to implement the function
3706  * of cancelling a record written into the log.  The first pass
3707  * determines those things which have been cancelled, and the
3708  * second pass replays log items normally except for those which
3709  * have been cancelled.  The handling of the replay and cancellations
3710  * takes place in the log item type specific routines.
3711  *
3712  * The table of items which have cancel records in the log is allocated
3713  * and freed at this level, since only here do we know when all of
3714  * the log recovery has been completed.
3715  */
3716 STATIC int
3717 xlog_do_log_recovery(
3718         xlog_t          *log,
3719         xfs_daddr_t     head_blk,
3720         xfs_daddr_t     tail_blk)
3721 {
3722         int             error;
3723
3724         ASSERT(head_blk != tail_blk);
3725
3726         /*
3727          * First do a pass to find all of the cancelled buf log items.
3728          * Store them in the buf_cancel_table for use in the second pass.
3729          */
3730         log->l_buf_cancel_table =
3731                 (xfs_buf_cancel_t **)kmem_zalloc(XLOG_BC_TABLE_SIZE *
3732                                                  sizeof(xfs_buf_cancel_t*),
3733                                                  KM_SLEEP);
3734         error = xlog_do_recovery_pass(log, head_blk, tail_blk,
3735                                       XLOG_RECOVER_PASS1);
3736         if (error != 0) {
3737                 kmem_free(log->l_buf_cancel_table);
3738                 log->l_buf_cancel_table = NULL;
3739                 return error;
3740         }
3741         /*
3742          * Then do a second pass to actually recover the items in the log.
3743          * When it is complete free the table of buf cancel items.
3744          */
3745         error = xlog_do_recovery_pass(log, head_blk, tail_blk,
3746                                       XLOG_RECOVER_PASS2);
3747 #ifdef DEBUG
3748         if (!error) {
3749                 int     i;
3750
3751                 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
3752                         ASSERT(log->l_buf_cancel_table[i] == NULL);
3753         }
3754 #endif  /* DEBUG */
3755
3756         kmem_free(log->l_buf_cancel_table);
3757         log->l_buf_cancel_table = NULL;
3758
3759         return error;
3760 }
3761
3762 /*
3763  * Do the actual recovery
3764  */
3765 STATIC int
3766 xlog_do_recover(
3767         xlog_t          *log,
3768         xfs_daddr_t     head_blk,
3769         xfs_daddr_t     tail_blk)
3770 {
3771         int             error;
3772         xfs_buf_t       *bp;
3773         xfs_sb_t        *sbp;
3774
3775         /*
3776          * First replay the images in the log.
3777          */
3778         error = xlog_do_log_recovery(log, head_blk, tail_blk);
3779         if (error) {
3780                 return error;
3781         }
3782
3783         XFS_bflush(log->l_mp->m_ddev_targp);
3784
3785         /*
3786          * If IO errors happened during recovery, bail out.
3787          */
3788         if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
3789                 return (EIO);
3790         }
3791
3792         /*
3793          * We now update the tail_lsn since much of the recovery has completed
3794          * and there may be space available to use.  If there were no extent
3795          * or iunlinks, we can free up the entire log and set the tail_lsn to
3796          * be the last_sync_lsn.  This was set in xlog_find_tail to be the
3797          * lsn of the last known good LR on disk.  If there are extent frees
3798          * or iunlinks they will have some entries in the AIL; so we look at
3799          * the AIL to determine how to set the tail_lsn.
3800          */
3801         xlog_assign_tail_lsn(log->l_mp);
3802
3803         /*
3804          * Now that we've finished replaying all buffer and inode
3805          * updates, re-read in the superblock.
3806          */
3807         bp = xfs_getsb(log->l_mp, 0);
3808         XFS_BUF_UNDONE(bp);
3809         ASSERT(!(XFS_BUF_ISWRITE(bp)));
3810         ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
3811         XFS_BUF_READ(bp);
3812         XFS_BUF_UNASYNC(bp);
3813         xfsbdstrat(log->l_mp, bp);
3814         error = xfs_iowait(bp);
3815         if (error) {
3816                 xfs_ioerror_alert("xlog_do_recover",
3817                                   log->l_mp, bp, XFS_BUF_ADDR(bp));
3818                 ASSERT(0);
3819                 xfs_buf_relse(bp);
3820                 return error;
3821         }
3822
3823         /* Convert superblock from on-disk format */
3824         sbp = &log->l_mp->m_sb;
3825         xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
3826         ASSERT(sbp->sb_magicnum == XFS_SB_MAGIC);
3827         ASSERT(xfs_sb_good_version(sbp));
3828         xfs_buf_relse(bp);
3829
3830         /* We've re-read the superblock so re-initialize per-cpu counters */
3831         xfs_icsb_reinit_counters(log->l_mp);
3832
3833         xlog_recover_check_summary(log);
3834
3835         /* Normal transactions can now occur */
3836         log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
3837         return 0;
3838 }
3839
3840 /*
3841  * Perform recovery and re-initialize some log variables in xlog_find_tail.
3842  *
3843  * Return error or zero.
3844  */
3845 int
3846 xlog_recover(
3847         xlog_t          *log)
3848 {
3849         xfs_daddr_t     head_blk, tail_blk;
3850         int             error;
3851
3852         /* find the tail of the log */
3853         if ((error = xlog_find_tail(log, &head_blk, &tail_blk)))
3854                 return error;
3855
3856         if (tail_blk != head_blk) {
3857                 /* There used to be a comment here:
3858                  *
3859                  * disallow recovery on read-only mounts.  note -- mount
3860                  * checks for ENOSPC and turns it into an intelligent
3861                  * error message.
3862                  * ...but this is no longer true.  Now, unless you specify
3863                  * NORECOVERY (in which case this function would never be
3864                  * called), we just go ahead and recover.  We do this all
3865                  * under the vfs layer, so we can get away with it unless
3866                  * the device itself is read-only, in which case we fail.
3867                  */
3868                 if ((error = xfs_dev_is_read_only(log->l_mp, "recovery"))) {
3869                         return error;
3870                 }
3871
3872                 cmn_err(CE_NOTE,
3873                         "Starting XFS recovery on filesystem: %s (logdev: %s)",
3874                         log->l_mp->m_fsname, log->l_mp->m_logname ?
3875                         log->l_mp->m_logname : "internal");
3876
3877                 error = xlog_do_recover(log, head_blk, tail_blk);
3878                 log->l_flags |= XLOG_RECOVERY_NEEDED;
3879         }
3880         return error;
3881 }
3882
3883 /*
3884  * In the first part of recovery we replay inodes and buffers and build
3885  * up the list of extent free items which need to be processed.  Here
3886  * we process the extent free items and clean up the on disk unlinked
3887  * inode lists.  This is separated from the first part of recovery so
3888  * that the root and real-time bitmap inodes can be read in from disk in
3889  * between the two stages.  This is necessary so that we can free space
3890  * in the real-time portion of the file system.
3891  */
3892 int
3893 xlog_recover_finish(
3894         xlog_t          *log)
3895 {
3896         /*
3897          * Now we're ready to do the transactions needed for the
3898          * rest of recovery.  Start with completing all the extent
3899          * free intent records and then process the unlinked inode
3900          * lists.  At this point, we essentially run in normal mode
3901          * except that we're still performing recovery actions
3902          * rather than accepting new requests.
3903          */
3904         if (log->l_flags & XLOG_RECOVERY_NEEDED) {
3905                 int     error;
3906                 error = xlog_recover_process_efis(log);
3907                 if (error) {
3908                         cmn_err(CE_ALERT,
3909                                 "Failed to recover EFIs on filesystem: %s",
3910                                 log->l_mp->m_fsname);
3911                         return error;
3912                 }
3913                 /*
3914                  * Sync the log to get all the EFIs out of the AIL.
3915                  * This isn't absolutely necessary, but it helps in
3916                  * case the unlink transactions would have problems
3917                  * pushing the EFIs out of the way.
3918                  */
3919                 xfs_log_force(log->l_mp, (xfs_lsn_t)0,
3920                               (XFS_LOG_FORCE | XFS_LOG_SYNC));
3921
3922                 xlog_recover_process_iunlinks(log);
3923
3924                 xlog_recover_check_summary(log);
3925
3926                 cmn_err(CE_NOTE,
3927                         "Ending XFS recovery on filesystem: %s (logdev: %s)",
3928                         log->l_mp->m_fsname, log->l_mp->m_logname ?
3929                         log->l_mp->m_logname : "internal");
3930                 log->l_flags &= ~XLOG_RECOVERY_NEEDED;
3931         } else {
3932                 cmn_err(CE_DEBUG,
3933                         "!Ending clean XFS mount for filesystem: %s\n",
3934                         log->l_mp->m_fsname);
3935         }
3936         return 0;
3937 }
3938
3939
3940 #if defined(DEBUG)
3941 /*
3942  * Read all of the agf and agi counters and check that they
3943  * are consistent with the superblock counters.
3944  */
3945 void
3946 xlog_recover_check_summary(
3947         xlog_t          *log)
3948 {
3949         xfs_mount_t     *mp;
3950         xfs_agf_t       *agfp;
3951         xfs_buf_t       *agfbp;
3952         xfs_buf_t       *agibp;
3953         xfs_buf_t       *sbbp;
3954 #ifdef XFS_LOUD_RECOVERY
3955         xfs_sb_t        *sbp;
3956 #endif
3957         xfs_agnumber_t  agno;
3958         __uint64_t      freeblks;
3959         __uint64_t      itotal;
3960         __uint64_t      ifree;
3961         int             error;
3962
3963         mp = log->l_mp;
3964
3965         freeblks = 0LL;
3966         itotal = 0LL;
3967         ifree = 0LL;
3968         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
3969                 error = xfs_read_agf(mp, NULL, agno, 0, &agfbp);
3970                 if (error) {
3971                         xfs_fs_cmn_err(CE_ALERT, mp,
3972                                         "xlog_recover_check_summary(agf)"
3973                                         "agf read failed agno %d error %d",
3974                                                         agno, error);
3975                 } else {
3976                         agfp = XFS_BUF_TO_AGF(agfbp);
3977                         freeblks += be32_to_cpu(agfp->agf_freeblks) +
3978                                     be32_to_cpu(agfp->agf_flcount);
3979                         xfs_buf_relse(agfbp);
3980                 }
3981
3982                 error = xfs_read_agi(mp, NULL, agno, &agibp);
3983                 if (!error) {
3984                         struct xfs_agi  *agi = XFS_BUF_TO_AGI(agibp);
3985
3986                         itotal += be32_to_cpu(agi->agi_count);
3987                         ifree += be32_to_cpu(agi->agi_freecount);
3988                         xfs_buf_relse(agibp);
3989                 }
3990         }
3991
3992         sbbp = xfs_getsb(mp, 0);
3993 #ifdef XFS_LOUD_RECOVERY
3994         sbp = &mp->m_sb;
3995         xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(sbbp));
3996         cmn_err(CE_NOTE,
3997                 "xlog_recover_check_summary: sb_icount %Lu itotal %Lu",
3998                 sbp->sb_icount, itotal);
3999         cmn_err(CE_NOTE,
4000                 "xlog_recover_check_summary: sb_ifree %Lu itotal %Lu",
4001                 sbp->sb_ifree, ifree);
4002         cmn_err(CE_NOTE,
4003                 "xlog_recover_check_summary: sb_fdblocks %Lu freeblks %Lu",
4004                 sbp->sb_fdblocks, freeblks);
4005 #if 0
4006         /*
4007          * This is turned off until I account for the allocation
4008          * btree blocks which live in free space.
4009          */
4010         ASSERT(sbp->sb_icount == itotal);
4011         ASSERT(sbp->sb_ifree == ifree);
4012         ASSERT(sbp->sb_fdblocks == freeblks);
4013 #endif
4014 #endif
4015         xfs_buf_relse(sbbp);
4016 }
4017 #endif /* DEBUG */