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