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