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