xfs: event tracing support
[sfrench/cifs-2.6.git] / fs / xfs / xfs_log_recover.c
1 /*
2  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_types.h"
21 #include "xfs_bit.h"
22 #include "xfs_log.h"
23 #include "xfs_inum.h"
24 #include "xfs_trans.h"
25 #include "xfs_sb.h"
26 #include "xfs_ag.h"
27 #include "xfs_dir2.h"
28 #include "xfs_dmapi.h"
29 #include "xfs_mount.h"
30 #include "xfs_error.h"
31 #include "xfs_bmap_btree.h"
32 #include "xfs_alloc_btree.h"
33 #include "xfs_ialloc_btree.h"
34 #include "xfs_dir2_sf.h"
35 #include "xfs_attr_sf.h"
36 #include "xfs_dinode.h"
37 #include "xfs_inode.h"
38 #include "xfs_inode_item.h"
39 #include "xfs_alloc.h"
40 #include "xfs_ialloc.h"
41 #include "xfs_log_priv.h"
42 #include "xfs_buf_item.h"
43 #include "xfs_log_recover.h"
44 #include "xfs_extfree_item.h"
45 #include "xfs_trans_priv.h"
46 #include "xfs_quota.h"
47 #include "xfs_rw.h"
48 #include "xfs_utils.h"
49 #include "xfs_trace.h"
50
51 STATIC int      xlog_find_zeroed(xlog_t *, xfs_daddr_t *);
52 STATIC int      xlog_clear_stale_blocks(xlog_t *, xfs_lsn_t);
53 STATIC void     xlog_recover_insert_item_backq(xlog_recover_item_t **q,
54                                                xlog_recover_item_t *item);
55 #if defined(DEBUG)
56 STATIC void     xlog_recover_check_summary(xlog_t *);
57 #else
58 #define xlog_recover_check_summary(log)
59 #endif
60
61
62 /*
63  * Sector aligned buffer routines for buffer create/read/write/access
64  */
65
66 #define XLOG_SECTOR_ROUNDUP_BBCOUNT(log, bbs)   \
67         ( ((log)->l_sectbb_mask && (bbs & (log)->l_sectbb_mask)) ? \
68         ((bbs + (log)->l_sectbb_mask + 1) & ~(log)->l_sectbb_mask) : (bbs) )
69 #define XLOG_SECTOR_ROUNDDOWN_BLKNO(log, bno)   ((bno) & ~(log)->l_sectbb_mask)
70
71 xfs_buf_t *
72 xlog_get_bp(
73         xlog_t          *log,
74         int             nbblks)
75 {
76         if (nbblks <= 0 || nbblks > log->l_logBBsize) {
77                 xlog_warn("XFS: Invalid block length (0x%x) given for buffer", nbblks);
78                 XFS_ERROR_REPORT("xlog_get_bp(1)",
79                                  XFS_ERRLEVEL_HIGH, log->l_mp);
80                 return NULL;
81         }
82
83         if (log->l_sectbb_log) {
84                 if (nbblks > 1)
85                         nbblks += XLOG_SECTOR_ROUNDUP_BBCOUNT(log, 1);
86                 nbblks = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, nbblks);
87         }
88         return xfs_buf_get_noaddr(BBTOB(nbblks), log->l_mp->m_logdev_targp);
89 }
90
91 void
92 xlog_put_bp(
93         xfs_buf_t       *bp)
94 {
95         xfs_buf_free(bp);
96 }
97
98 STATIC xfs_caddr_t
99 xlog_align(
100         xlog_t          *log,
101         xfs_daddr_t     blk_no,
102         int             nbblks,
103         xfs_buf_t       *bp)
104 {
105         xfs_caddr_t     ptr;
106
107         if (!log->l_sectbb_log)
108                 return XFS_BUF_PTR(bp);
109
110         ptr = XFS_BUF_PTR(bp) + BBTOB((int)blk_no & log->l_sectbb_mask);
111         ASSERT(XFS_BUF_SIZE(bp) >=
112                 BBTOB(nbblks + (blk_no & log->l_sectbb_mask)));
113         return ptr;
114 }
115
116
117 /*
118  * nbblks should be uint, but oh well.  Just want to catch that 32-bit length.
119  */
120 STATIC int
121 xlog_bread_noalign(
122         xlog_t          *log,
123         xfs_daddr_t     blk_no,
124         int             nbblks,
125         xfs_buf_t       *bp)
126 {
127         int             error;
128
129         if (nbblks <= 0 || nbblks > log->l_logBBsize) {
130                 xlog_warn("XFS: Invalid block length (0x%x) given for buffer", nbblks);
131                 XFS_ERROR_REPORT("xlog_bread(1)",
132                                  XFS_ERRLEVEL_HIGH, log->l_mp);
133                 return EFSCORRUPTED;
134         }
135
136         if (log->l_sectbb_log) {
137                 blk_no = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, blk_no);
138                 nbblks = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, nbblks);
139         }
140
141         ASSERT(nbblks > 0);
142         ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));
143         ASSERT(bp);
144
145         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
146         XFS_BUF_READ(bp);
147         XFS_BUF_BUSY(bp);
148         XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
149         XFS_BUF_SET_TARGET(bp, log->l_mp->m_logdev_targp);
150
151         xfsbdstrat(log->l_mp, bp);
152         error = xfs_iowait(bp);
153         if (error)
154                 xfs_ioerror_alert("xlog_bread", log->l_mp,
155                                   bp, XFS_BUF_ADDR(bp));
156         return error;
157 }
158
159 STATIC int
160 xlog_bread(
161         xlog_t          *log,
162         xfs_daddr_t     blk_no,
163         int             nbblks,
164         xfs_buf_t       *bp,
165         xfs_caddr_t     *offset)
166 {
167         int             error;
168
169         error = xlog_bread_noalign(log, blk_no, nbblks, bp);
170         if (error)
171                 return error;
172
173         *offset = xlog_align(log, blk_no, nbblks, bp);
174         return 0;
175 }
176
177 /*
178  * Write out the buffer at the given block for the given number of blocks.
179  * The buffer is kept locked across the write and is returned locked.
180  * This can only be used for synchronous log writes.
181  */
182 STATIC int
183 xlog_bwrite(
184         xlog_t          *log,
185         xfs_daddr_t     blk_no,
186         int             nbblks,
187         xfs_buf_t       *bp)
188 {
189         int             error;
190
191         if (nbblks <= 0 || nbblks > log->l_logBBsize) {
192                 xlog_warn("XFS: Invalid block length (0x%x) given for buffer", nbblks);
193                 XFS_ERROR_REPORT("xlog_bwrite(1)",
194                                  XFS_ERRLEVEL_HIGH, log->l_mp);
195                 return EFSCORRUPTED;
196         }
197
198         if (log->l_sectbb_log) {
199                 blk_no = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, blk_no);
200                 nbblks = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, nbblks);
201         }
202
203         ASSERT(nbblks > 0);
204         ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));
205
206         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
207         XFS_BUF_ZEROFLAGS(bp);
208         XFS_BUF_BUSY(bp);
209         XFS_BUF_HOLD(bp);
210         XFS_BUF_PSEMA(bp, PRIBIO);
211         XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
212         XFS_BUF_SET_TARGET(bp, log->l_mp->m_logdev_targp);
213
214         if ((error = xfs_bwrite(log->l_mp, bp)))
215                 xfs_ioerror_alert("xlog_bwrite", log->l_mp,
216                                   bp, XFS_BUF_ADDR(bp));
217         return error;
218 }
219
220 #ifdef DEBUG
221 /*
222  * dump debug superblock and log record information
223  */
224 STATIC void
225 xlog_header_check_dump(
226         xfs_mount_t             *mp,
227         xlog_rec_header_t       *head)
228 {
229         int                     b;
230
231         cmn_err(CE_DEBUG, "%s:  SB : uuid = ", __func__);
232         for (b = 0; b < 16; b++)
233                 cmn_err(CE_DEBUG, "%02x", ((__uint8_t *)&mp->m_sb.sb_uuid)[b]);
234         cmn_err(CE_DEBUG, ", fmt = %d\n", XLOG_FMT);
235         cmn_err(CE_DEBUG, "    log : uuid = ");
236         for (b = 0; b < 16; b++)
237                 cmn_err(CE_DEBUG, "%02x", ((__uint8_t *)&head->h_fs_uuid)[b]);
238         cmn_err(CE_DEBUG, ", fmt = %d\n", be32_to_cpu(head->h_fmt));
239 }
240 #else
241 #define xlog_header_check_dump(mp, head)
242 #endif
243
244 /*
245  * check log record header for recovery
246  */
247 STATIC int
248 xlog_header_check_recover(
249         xfs_mount_t             *mp,
250         xlog_rec_header_t       *head)
251 {
252         ASSERT(be32_to_cpu(head->h_magicno) == XLOG_HEADER_MAGIC_NUM);
253
254         /*
255          * IRIX doesn't write the h_fmt field and leaves it zeroed
256          * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
257          * a dirty log created in IRIX.
258          */
259         if (unlikely(be32_to_cpu(head->h_fmt) != XLOG_FMT)) {
260                 xlog_warn(
261         "XFS: dirty log written in incompatible format - can't recover");
262                 xlog_header_check_dump(mp, head);
263                 XFS_ERROR_REPORT("xlog_header_check_recover(1)",
264                                  XFS_ERRLEVEL_HIGH, mp);
265                 return XFS_ERROR(EFSCORRUPTED);
266         } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
267                 xlog_warn(
268         "XFS: dirty log entry has mismatched uuid - can't recover");
269                 xlog_header_check_dump(mp, head);
270                 XFS_ERROR_REPORT("xlog_header_check_recover(2)",
271                                  XFS_ERRLEVEL_HIGH, mp);
272                 return XFS_ERROR(EFSCORRUPTED);
273         }
274         return 0;
275 }
276
277 /*
278  * read the head block of the log and check the header
279  */
280 STATIC int
281 xlog_header_check_mount(
282         xfs_mount_t             *mp,
283         xlog_rec_header_t       *head)
284 {
285         ASSERT(be32_to_cpu(head->h_magicno) == XLOG_HEADER_MAGIC_NUM);
286
287         if (uuid_is_nil(&head->h_fs_uuid)) {
288                 /*
289                  * IRIX doesn't write the h_fs_uuid or h_fmt fields. If
290                  * h_fs_uuid is nil, we assume this log was last mounted
291                  * by IRIX and continue.
292                  */
293                 xlog_warn("XFS: nil uuid in log - IRIX style log");
294         } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
295                 xlog_warn("XFS: log has mismatched uuid - can't recover");
296                 xlog_header_check_dump(mp, head);
297                 XFS_ERROR_REPORT("xlog_header_check_mount",
298                                  XFS_ERRLEVEL_HIGH, mp);
299                 return XFS_ERROR(EFSCORRUPTED);
300         }
301         return 0;
302 }
303
304 STATIC void
305 xlog_recover_iodone(
306         struct xfs_buf  *bp)
307 {
308         if (XFS_BUF_GETERROR(bp)) {
309                 /*
310                  * We're not going to bother about retrying
311                  * this during recovery. One strike!
312                  */
313                 xfs_ioerror_alert("xlog_recover_iodone",
314                                   bp->b_mount, bp, XFS_BUF_ADDR(bp));
315                 xfs_force_shutdown(bp->b_mount, SHUTDOWN_META_IO_ERROR);
316         }
317         bp->b_mount = NULL;
318         XFS_BUF_CLR_IODONE_FUNC(bp);
319         xfs_biodone(bp);
320 }
321
322 /*
323  * This routine finds (to an approximation) the first block in the physical
324  * log which contains the given cycle.  It uses a binary search algorithm.
325  * Note that the algorithm can not be perfect because the disk will not
326  * necessarily be perfect.
327  */
328 STATIC int
329 xlog_find_cycle_start(
330         xlog_t          *log,
331         xfs_buf_t       *bp,
332         xfs_daddr_t     first_blk,
333         xfs_daddr_t     *last_blk,
334         uint            cycle)
335 {
336         xfs_caddr_t     offset;
337         xfs_daddr_t     mid_blk;
338         uint            mid_cycle;
339         int             error;
340
341         mid_blk = BLK_AVG(first_blk, *last_blk);
342         while (mid_blk != first_blk && mid_blk != *last_blk) {
343                 error = xlog_bread(log, mid_blk, 1, bp, &offset);
344                 if (error)
345                         return error;
346                 mid_cycle = xlog_get_cycle(offset);
347                 if (mid_cycle == cycle) {
348                         *last_blk = mid_blk;
349                         /* last_half_cycle == mid_cycle */
350                 } else {
351                         first_blk = mid_blk;
352                         /* first_half_cycle == mid_cycle */
353                 }
354                 mid_blk = BLK_AVG(first_blk, *last_blk);
355         }
356         ASSERT((mid_blk == first_blk && mid_blk+1 == *last_blk) ||
357                (mid_blk == *last_blk && mid_blk-1 == first_blk));
358
359         return 0;
360 }
361
362 /*
363  * Check that the range of blocks does not contain the cycle number
364  * given.  The scan needs to occur from front to back and the ptr into the
365  * region must be updated since a later routine will need to perform another
366  * test.  If the region is completely good, we end up returning the same
367  * last block number.
368  *
369  * Set blkno to -1 if we encounter no errors.  This is an invalid block number
370  * since we don't ever expect logs to get this large.
371  */
372 STATIC int
373 xlog_find_verify_cycle(
374         xlog_t          *log,
375         xfs_daddr_t     start_blk,
376         int             nbblks,
377         uint            stop_on_cycle_no,
378         xfs_daddr_t     *new_blk)
379 {
380         xfs_daddr_t     i, j;
381         uint            cycle;
382         xfs_buf_t       *bp;
383         xfs_daddr_t     bufblks;
384         xfs_caddr_t     buf = NULL;
385         int             error = 0;
386
387         bufblks = 1 << ffs(nbblks);
388
389         while (!(bp = xlog_get_bp(log, bufblks))) {
390                 /* can't get enough memory to do everything in one big buffer */
391                 bufblks >>= 1;
392                 if (bufblks <= log->l_sectbb_log)
393                         return ENOMEM;
394         }
395
396         for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
397                 int     bcount;
398
399                 bcount = min(bufblks, (start_blk + nbblks - i));
400
401                 error = xlog_bread(log, i, bcount, bp, &buf);
402                 if (error)
403                         goto out;
404
405                 for (j = 0; j < bcount; j++) {
406                         cycle = xlog_get_cycle(buf);
407                         if (cycle == stop_on_cycle_no) {
408                                 *new_blk = i+j;
409                                 goto out;
410                         }
411
412                         buf += BBSIZE;
413                 }
414         }
415
416         *new_blk = -1;
417
418 out:
419         xlog_put_bp(bp);
420         return error;
421 }
422
423 /*
424  * Potentially backup over partial log record write.
425  *
426  * In the typical case, last_blk is the number of the block directly after
427  * a good log record.  Therefore, we subtract one to get the block number
428  * of the last block in the given buffer.  extra_bblks contains the number
429  * of blocks we would have read on a previous read.  This happens when the
430  * last log record is split over the end of the physical log.
431  *
432  * extra_bblks is the number of blocks potentially verified on a previous
433  * call to this routine.
434  */
435 STATIC int
436 xlog_find_verify_log_record(
437         xlog_t                  *log,
438         xfs_daddr_t             start_blk,
439         xfs_daddr_t             *last_blk,
440         int                     extra_bblks)
441 {
442         xfs_daddr_t             i;
443         xfs_buf_t               *bp;
444         xfs_caddr_t             offset = NULL;
445         xlog_rec_header_t       *head = NULL;
446         int                     error = 0;
447         int                     smallmem = 0;
448         int                     num_blks = *last_blk - start_blk;
449         int                     xhdrs;
450
451         ASSERT(start_blk != 0 || *last_blk != start_blk);
452
453         if (!(bp = xlog_get_bp(log, num_blks))) {
454                 if (!(bp = xlog_get_bp(log, 1)))
455                         return ENOMEM;
456                 smallmem = 1;
457         } else {
458                 error = xlog_bread(log, start_blk, num_blks, bp, &offset);
459                 if (error)
460                         goto out;
461                 offset += ((num_blks - 1) << BBSHIFT);
462         }
463
464         for (i = (*last_blk) - 1; i >= 0; i--) {
465                 if (i < start_blk) {
466                         /* valid log record not found */
467                         xlog_warn(
468                 "XFS: Log inconsistent (didn't find previous header)");
469                         ASSERT(0);
470                         error = XFS_ERROR(EIO);
471                         goto out;
472                 }
473
474                 if (smallmem) {
475                         error = xlog_bread(log, i, 1, bp, &offset);
476                         if (error)
477                                 goto out;
478                 }
479
480                 head = (xlog_rec_header_t *)offset;
481
482                 if (XLOG_HEADER_MAGIC_NUM == be32_to_cpu(head->h_magicno))
483                         break;
484
485                 if (!smallmem)
486                         offset -= BBSIZE;
487         }
488
489         /*
490          * We hit the beginning of the physical log & still no header.  Return
491          * to caller.  If caller can handle a return of -1, then this routine
492          * will be called again for the end of the physical log.
493          */
494         if (i == -1) {
495                 error = -1;
496                 goto out;
497         }
498
499         /*
500          * We have the final block of the good log (the first block
501          * of the log record _before_ the head. So we check the uuid.
502          */
503         if ((error = xlog_header_check_mount(log->l_mp, head)))
504                 goto out;
505
506         /*
507          * We may have found a log record header before we expected one.
508          * last_blk will be the 1st block # with a given cycle #.  We may end
509          * up reading an entire log record.  In this case, we don't want to
510          * reset last_blk.  Only when last_blk points in the middle of a log
511          * record do we update last_blk.
512          */
513         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
514                 uint    h_size = be32_to_cpu(head->h_size);
515
516                 xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
517                 if (h_size % XLOG_HEADER_CYCLE_SIZE)
518                         xhdrs++;
519         } else {
520                 xhdrs = 1;
521         }
522
523         if (*last_blk - i + extra_bblks !=
524             BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
525                 *last_blk = i;
526
527 out:
528         xlog_put_bp(bp);
529         return error;
530 }
531
532 /*
533  * Head is defined to be the point of the log where the next log write
534  * write could go.  This means that incomplete LR writes at the end are
535  * eliminated when calculating the head.  We aren't guaranteed that previous
536  * LR have complete transactions.  We only know that a cycle number of
537  * current cycle number -1 won't be present in the log if we start writing
538  * from our current block number.
539  *
540  * last_blk contains the block number of the first block with a given
541  * cycle number.
542  *
543  * Return: zero if normal, non-zero if error.
544  */
545 STATIC int
546 xlog_find_head(
547         xlog_t          *log,
548         xfs_daddr_t     *return_head_blk)
549 {
550         xfs_buf_t       *bp;
551         xfs_caddr_t     offset;
552         xfs_daddr_t     new_blk, first_blk, start_blk, last_blk, head_blk;
553         int             num_scan_bblks;
554         uint            first_half_cycle, last_half_cycle;
555         uint            stop_on_cycle;
556         int             error, log_bbnum = log->l_logBBsize;
557
558         /* Is the end of the log device zeroed? */
559         if ((error = xlog_find_zeroed(log, &first_blk)) == -1) {
560                 *return_head_blk = first_blk;
561
562                 /* Is the whole lot zeroed? */
563                 if (!first_blk) {
564                         /* Linux XFS shouldn't generate totally zeroed logs -
565                          * mkfs etc write a dummy unmount record to a fresh
566                          * log so we can store the uuid in there
567                          */
568                         xlog_warn("XFS: totally zeroed log");
569                 }
570
571                 return 0;
572         } else if (error) {
573                 xlog_warn("XFS: empty log check failed");
574                 return error;
575         }
576
577         first_blk = 0;                  /* get cycle # of 1st block */
578         bp = xlog_get_bp(log, 1);
579         if (!bp)
580                 return ENOMEM;
581
582         error = xlog_bread(log, 0, 1, bp, &offset);
583         if (error)
584                 goto bp_err;
585
586         first_half_cycle = xlog_get_cycle(offset);
587
588         last_blk = head_blk = log_bbnum - 1;    /* get cycle # of last block */
589         error = xlog_bread(log, last_blk, 1, bp, &offset);
590         if (error)
591                 goto bp_err;
592
593         last_half_cycle = xlog_get_cycle(offset);
594         ASSERT(last_half_cycle != 0);
595
596         /*
597          * If the 1st half cycle number is equal to the last half cycle number,
598          * then the entire log is stamped with the same cycle number.  In this
599          * case, head_blk can't be set to zero (which makes sense).  The below
600          * math doesn't work out properly with head_blk equal to zero.  Instead,
601          * we set it to log_bbnum which is an invalid block number, but this
602          * value makes the math correct.  If head_blk doesn't changed through
603          * all the tests below, *head_blk is set to zero at the very end rather
604          * than log_bbnum.  In a sense, log_bbnum and zero are the same block
605          * in a circular file.
606          */
607         if (first_half_cycle == last_half_cycle) {
608                 /*
609                  * In this case we believe that the entire log should have
610                  * cycle number last_half_cycle.  We need to scan backwards
611                  * from the end verifying that there are no holes still
612                  * containing last_half_cycle - 1.  If we find such a hole,
613                  * then the start of that hole will be the new head.  The
614                  * simple case looks like
615                  *        x | x ... | x - 1 | x
616                  * Another case that fits this picture would be
617                  *        x | x + 1 | x ... | x
618                  * In this case the head really is somewhere at the end of the
619                  * log, as one of the latest writes at the beginning was
620                  * incomplete.
621                  * One more case is
622                  *        x | x + 1 | x ... | x - 1 | x
623                  * This is really the combination of the above two cases, and
624                  * the head has to end up at the start of the x-1 hole at the
625                  * end of the log.
626                  *
627                  * In the 256k log case, we will read from the beginning to the
628                  * end of the log and search for cycle numbers equal to x-1.
629                  * We don't worry about the x+1 blocks that we encounter,
630                  * because we know that they cannot be the head since the log
631                  * started with x.
632                  */
633                 head_blk = log_bbnum;
634                 stop_on_cycle = last_half_cycle - 1;
635         } else {
636                 /*
637                  * In this case we want to find the first block with cycle
638                  * number matching last_half_cycle.  We expect the log to be
639                  * some variation on
640                  *        x + 1 ... | x ...
641                  * The first block with cycle number x (last_half_cycle) will
642                  * be where the new head belongs.  First we do a binary search
643                  * for the first occurrence of last_half_cycle.  The binary
644                  * search may not be totally accurate, so then we scan back
645                  * from there looking for occurrences of last_half_cycle before
646                  * us.  If that backwards scan wraps around the beginning of
647                  * the log, then we look for occurrences of last_half_cycle - 1
648                  * at the end of the log.  The cases we're looking for look
649                  * like
650                  *        x + 1 ... | x | x + 1 | x ...
651                  *                               ^ binary search stopped here
652                  * or
653                  *        x + 1 ... | x ... | x - 1 | x
654                  *        <---------> less than scan distance
655                  */
656                 stop_on_cycle = last_half_cycle;
657                 if ((error = xlog_find_cycle_start(log, bp, first_blk,
658                                                 &head_blk, last_half_cycle)))
659                         goto bp_err;
660         }
661
662         /*
663          * Now validate the answer.  Scan back some number of maximum possible
664          * blocks and make sure each one has the expected cycle number.  The
665          * maximum is determined by the total possible amount of buffering
666          * in the in-core log.  The following number can be made tighter if
667          * we actually look at the block size of the filesystem.
668          */
669         num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
670         if (head_blk >= num_scan_bblks) {
671                 /*
672                  * We are guaranteed that the entire check can be performed
673                  * in one buffer.
674                  */
675                 start_blk = head_blk - num_scan_bblks;
676                 if ((error = xlog_find_verify_cycle(log,
677                                                 start_blk, num_scan_bblks,
678                                                 stop_on_cycle, &new_blk)))
679                         goto bp_err;
680                 if (new_blk != -1)
681                         head_blk = new_blk;
682         } else {                /* need to read 2 parts of log */
683                 /*
684                  * We are going to scan backwards in the log in two parts.
685                  * First we scan the physical end of the log.  In this part
686                  * of the log, we are looking for blocks with cycle number
687                  * last_half_cycle - 1.
688                  * If we find one, then we know that the log starts there, as
689                  * we've found a hole that didn't get written in going around
690                  * the end of the physical log.  The simple case for this is
691                  *        x + 1 ... | x ... | x - 1 | x
692                  *        <---------> less than scan distance
693                  * If all of the blocks at the end of the log have cycle number
694                  * last_half_cycle, then we check the blocks at the start of
695                  * the log looking for occurrences of last_half_cycle.  If we
696                  * find one, then our current estimate for the location of the
697                  * first occurrence of last_half_cycle is wrong and we move
698                  * back to the hole we've found.  This case looks like
699                  *        x + 1 ... | x | x + 1 | x ...
700                  *                               ^ binary search stopped here
701                  * Another case we need to handle that only occurs in 256k
702                  * logs is
703                  *        x + 1 ... | x ... | x+1 | x ...
704                  *                   ^ binary search stops here
705                  * In a 256k log, the scan at the end of the log will see the
706                  * x + 1 blocks.  We need to skip past those since that is
707                  * certainly not the head of the log.  By searching for
708                  * last_half_cycle-1 we accomplish that.
709                  */
710                 start_blk = log_bbnum - num_scan_bblks + head_blk;
711                 ASSERT(head_blk <= INT_MAX &&
712                         (xfs_daddr_t) num_scan_bblks - head_blk >= 0);
713                 if ((error = xlog_find_verify_cycle(log, start_blk,
714                                         num_scan_bblks - (int)head_blk,
715                                         (stop_on_cycle - 1), &new_blk)))
716                         goto bp_err;
717                 if (new_blk != -1) {
718                         head_blk = new_blk;
719                         goto bad_blk;
720                 }
721
722                 /*
723                  * Scan beginning of log now.  The last part of the physical
724                  * log is good.  This scan needs to verify that it doesn't find
725                  * the last_half_cycle.
726                  */
727                 start_blk = 0;
728                 ASSERT(head_blk <= INT_MAX);
729                 if ((error = xlog_find_verify_cycle(log,
730                                         start_blk, (int)head_blk,
731                                         stop_on_cycle, &new_blk)))
732                         goto bp_err;
733                 if (new_blk != -1)
734                         head_blk = new_blk;
735         }
736
737  bad_blk:
738         /*
739          * Now we need to make sure head_blk is not pointing to a block in
740          * the middle of a log record.
741          */
742         num_scan_bblks = XLOG_REC_SHIFT(log);
743         if (head_blk >= num_scan_bblks) {
744                 start_blk = head_blk - num_scan_bblks; /* don't read head_blk */
745
746                 /* start ptr at last block ptr before head_blk */
747                 if ((error = xlog_find_verify_log_record(log, start_blk,
748                                                         &head_blk, 0)) == -1) {
749                         error = XFS_ERROR(EIO);
750                         goto bp_err;
751                 } else if (error)
752                         goto bp_err;
753         } else {
754                 start_blk = 0;
755                 ASSERT(head_blk <= INT_MAX);
756                 if ((error = xlog_find_verify_log_record(log, start_blk,
757                                                         &head_blk, 0)) == -1) {
758                         /* We hit the beginning of the log during our search */
759                         start_blk = log_bbnum - num_scan_bblks + head_blk;
760                         new_blk = log_bbnum;
761                         ASSERT(start_blk <= INT_MAX &&
762                                 (xfs_daddr_t) log_bbnum-start_blk >= 0);
763                         ASSERT(head_blk <= INT_MAX);
764                         if ((error = xlog_find_verify_log_record(log,
765                                                         start_blk, &new_blk,
766                                                         (int)head_blk)) == -1) {
767                                 error = XFS_ERROR(EIO);
768                                 goto bp_err;
769                         } else if (error)
770                                 goto bp_err;
771                         if (new_blk != log_bbnum)
772                                 head_blk = new_blk;
773                 } else if (error)
774                         goto bp_err;
775         }
776
777         xlog_put_bp(bp);
778         if (head_blk == log_bbnum)
779                 *return_head_blk = 0;
780         else
781                 *return_head_blk = head_blk;
782         /*
783          * When returning here, we have a good block number.  Bad block
784          * means that during a previous crash, we didn't have a clean break
785          * from cycle number N to cycle number N-1.  In this case, we need
786          * to find the first block with cycle number N-1.
787          */
788         return 0;
789
790  bp_err:
791         xlog_put_bp(bp);
792
793         if (error)
794             xlog_warn("XFS: failed to find log head");
795         return error;
796 }
797
798 /*
799  * Find the sync block number or the tail of the log.
800  *
801  * This will be the block number of the last record to have its
802  * associated buffers synced to disk.  Every log record header has
803  * a sync lsn embedded in it.  LSNs hold block numbers, so it is easy
804  * to get a sync block number.  The only concern is to figure out which
805  * log record header to believe.
806  *
807  * The following algorithm uses the log record header with the largest
808  * lsn.  The entire log record does not need to be valid.  We only care
809  * that the header is valid.
810  *
811  * We could speed up search by using current head_blk buffer, but it is not
812  * available.
813  */
814 int
815 xlog_find_tail(
816         xlog_t                  *log,
817         xfs_daddr_t             *head_blk,
818         xfs_daddr_t             *tail_blk)
819 {
820         xlog_rec_header_t       *rhead;
821         xlog_op_header_t        *op_head;
822         xfs_caddr_t             offset = NULL;
823         xfs_buf_t               *bp;
824         int                     error, i, found;
825         xfs_daddr_t             umount_data_blk;
826         xfs_daddr_t             after_umount_blk;
827         xfs_lsn_t               tail_lsn;
828         int                     hblks;
829
830         found = 0;
831
832         /*
833          * Find previous log record
834          */
835         if ((error = xlog_find_head(log, head_blk)))
836                 return error;
837
838         bp = xlog_get_bp(log, 1);
839         if (!bp)
840                 return ENOMEM;
841         if (*head_blk == 0) {                           /* special case */
842                 error = xlog_bread(log, 0, 1, bp, &offset);
843                 if (error)
844                         goto bread_err;
845
846                 if (xlog_get_cycle(offset) == 0) {
847                         *tail_blk = 0;
848                         /* leave all other log inited values alone */
849                         goto exit;
850                 }
851         }
852
853         /*
854          * Search backwards looking for log record header block
855          */
856         ASSERT(*head_blk < INT_MAX);
857         for (i = (int)(*head_blk) - 1; i >= 0; i--) {
858                 error = xlog_bread(log, i, 1, bp, &offset);
859                 if (error)
860                         goto bread_err;
861
862                 if (XLOG_HEADER_MAGIC_NUM == be32_to_cpu(*(__be32 *)offset)) {
863                         found = 1;
864                         break;
865                 }
866         }
867         /*
868          * If we haven't found the log record header block, start looking
869          * again from the end of the physical log.  XXXmiken: There should be
870          * a check here to make sure we didn't search more than N blocks in
871          * the previous code.
872          */
873         if (!found) {
874                 for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {
875                         error = xlog_bread(log, i, 1, bp, &offset);
876                         if (error)
877                                 goto bread_err;
878
879                         if (XLOG_HEADER_MAGIC_NUM ==
880                             be32_to_cpu(*(__be32 *)offset)) {
881                                 found = 2;
882                                 break;
883                         }
884                 }
885         }
886         if (!found) {
887                 xlog_warn("XFS: xlog_find_tail: couldn't find sync record");
888                 ASSERT(0);
889                 return XFS_ERROR(EIO);
890         }
891
892         /* find blk_no of tail of log */
893         rhead = (xlog_rec_header_t *)offset;
894         *tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn));
895
896         /*
897          * Reset log values according to the state of the log when we
898          * crashed.  In the case where head_blk == 0, we bump curr_cycle
899          * one because the next write starts a new cycle rather than
900          * continuing the cycle of the last good log record.  At this
901          * point we have guaranteed that all partial log records have been
902          * accounted for.  Therefore, we know that the last good log record
903          * written was complete and ended exactly on the end boundary
904          * of the physical log.
905          */
906         log->l_prev_block = i;
907         log->l_curr_block = (int)*head_blk;
908         log->l_curr_cycle = be32_to_cpu(rhead->h_cycle);
909         if (found == 2)
910                 log->l_curr_cycle++;
911         log->l_tail_lsn = be64_to_cpu(rhead->h_tail_lsn);
912         log->l_last_sync_lsn = be64_to_cpu(rhead->h_lsn);
913         log->l_grant_reserve_cycle = log->l_curr_cycle;
914         log->l_grant_reserve_bytes = BBTOB(log->l_curr_block);
915         log->l_grant_write_cycle = log->l_curr_cycle;
916         log->l_grant_write_bytes = BBTOB(log->l_curr_block);
917
918         /*
919          * Look for unmount record.  If we find it, then we know there
920          * was a clean unmount.  Since 'i' could be the last block in
921          * the physical log, we convert to a log block before comparing
922          * to the head_blk.
923          *
924          * Save the current tail lsn to use to pass to
925          * xlog_clear_stale_blocks() below.  We won't want to clear the
926          * unmount record if there is one, so we pass the lsn of the
927          * unmount record rather than the block after it.
928          */
929         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
930                 int     h_size = be32_to_cpu(rhead->h_size);
931                 int     h_version = be32_to_cpu(rhead->h_version);
932
933                 if ((h_version & XLOG_VERSION_2) &&
934                     (h_size > XLOG_HEADER_CYCLE_SIZE)) {
935                         hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
936                         if (h_size % XLOG_HEADER_CYCLE_SIZE)
937                                 hblks++;
938                 } else {
939                         hblks = 1;
940                 }
941         } else {
942                 hblks = 1;
943         }
944         after_umount_blk = (i + hblks + (int)
945                 BTOBB(be32_to_cpu(rhead->h_len))) % log->l_logBBsize;
946         tail_lsn = log->l_tail_lsn;
947         if (*head_blk == after_umount_blk &&
948             be32_to_cpu(rhead->h_num_logops) == 1) {
949                 umount_data_blk = (i + hblks) % log->l_logBBsize;
950                 error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
951                 if (error)
952                         goto bread_err;
953
954                 op_head = (xlog_op_header_t *)offset;
955                 if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
956                         /*
957                          * Set tail and last sync so that newly written
958                          * log records will point recovery to after the
959                          * current unmount record.
960                          */
961                         log->l_tail_lsn =
962                                 xlog_assign_lsn(log->l_curr_cycle,
963                                                 after_umount_blk);
964                         log->l_last_sync_lsn =
965                                 xlog_assign_lsn(log->l_curr_cycle,
966                                                 after_umount_blk);
967                         *tail_blk = after_umount_blk;
968
969                         /*
970                          * Note that the unmount was clean. If the unmount
971                          * was not clean, we need to know this to rebuild the
972                          * superblock counters from the perag headers if we
973                          * have a filesystem using non-persistent counters.
974                          */
975                         log->l_mp->m_flags |= XFS_MOUNT_WAS_CLEAN;
976                 }
977         }
978
979         /*
980          * Make sure that there are no blocks in front of the head
981          * with the same cycle number as the head.  This can happen
982          * because we allow multiple outstanding log writes concurrently,
983          * and the later writes might make it out before earlier ones.
984          *
985          * We use the lsn from before modifying it so that we'll never
986          * overwrite the unmount record after a clean unmount.
987          *
988          * Do this only if we are going to recover the filesystem
989          *
990          * NOTE: This used to say "if (!readonly)"
991          * However on Linux, we can & do recover a read-only filesystem.
992          * We only skip recovery if NORECOVERY is specified on mount,
993          * in which case we would not be here.
994          *
995          * But... if the -device- itself is readonly, just skip this.
996          * We can't recover this device anyway, so it won't matter.
997          */
998         if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp)) {
999                 error = xlog_clear_stale_blocks(log, tail_lsn);
1000         }
1001
1002 bread_err:
1003 exit:
1004         xlog_put_bp(bp);
1005
1006         if (error)
1007                 xlog_warn("XFS: failed to locate log tail");
1008         return error;
1009 }
1010
1011 /*
1012  * Is the log zeroed at all?
1013  *
1014  * The last binary search should be changed to perform an X block read
1015  * once X becomes small enough.  You can then search linearly through
1016  * the X blocks.  This will cut down on the number of reads we need to do.
1017  *
1018  * If the log is partially zeroed, this routine will pass back the blkno
1019  * of the first block with cycle number 0.  It won't have a complete LR
1020  * preceding it.
1021  *
1022  * Return:
1023  *      0  => the log is completely written to
1024  *      -1 => use *blk_no as the first block of the log
1025  *      >0 => error has occurred
1026  */
1027 STATIC int
1028 xlog_find_zeroed(
1029         xlog_t          *log,
1030         xfs_daddr_t     *blk_no)
1031 {
1032         xfs_buf_t       *bp;
1033         xfs_caddr_t     offset;
1034         uint            first_cycle, last_cycle;
1035         xfs_daddr_t     new_blk, last_blk, start_blk;
1036         xfs_daddr_t     num_scan_bblks;
1037         int             error, log_bbnum = log->l_logBBsize;
1038
1039         *blk_no = 0;
1040
1041         /* check totally zeroed log */
1042         bp = xlog_get_bp(log, 1);
1043         if (!bp)
1044                 return ENOMEM;
1045         error = xlog_bread(log, 0, 1, bp, &offset);
1046         if (error)
1047                 goto bp_err;
1048
1049         first_cycle = xlog_get_cycle(offset);
1050         if (first_cycle == 0) {         /* completely zeroed log */
1051                 *blk_no = 0;
1052                 xlog_put_bp(bp);
1053                 return -1;
1054         }
1055
1056         /* check partially zeroed log */
1057         error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
1058         if (error)
1059                 goto bp_err;
1060
1061         last_cycle = xlog_get_cycle(offset);
1062         if (last_cycle != 0) {          /* log completely written to */
1063                 xlog_put_bp(bp);
1064                 return 0;
1065         } else if (first_cycle != 1) {
1066                 /*
1067                  * If the cycle of the last block is zero, the cycle of
1068                  * the first block must be 1. If it's not, maybe we're
1069                  * not looking at a log... Bail out.
1070                  */
1071                 xlog_warn("XFS: Log inconsistent or not a log (last==0, first!=1)");
1072                 return XFS_ERROR(EINVAL);
1073         }
1074
1075         /* we have a partially zeroed log */
1076         last_blk = log_bbnum-1;
1077         if ((error = xlog_find_cycle_start(log, bp, 0, &last_blk, 0)))
1078                 goto bp_err;
1079
1080         /*
1081          * Validate the answer.  Because there is no way to guarantee that
1082          * the entire log is made up of log records which are the same size,
1083          * we scan over the defined maximum blocks.  At this point, the maximum
1084          * is not chosen to mean anything special.   XXXmiken
1085          */
1086         num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
1087         ASSERT(num_scan_bblks <= INT_MAX);
1088
1089         if (last_blk < num_scan_bblks)
1090                 num_scan_bblks = last_blk;
1091         start_blk = last_blk - num_scan_bblks;
1092
1093         /*
1094          * We search for any instances of cycle number 0 that occur before
1095          * our current estimate of the head.  What we're trying to detect is
1096          *        1 ... | 0 | 1 | 0...
1097          *                       ^ binary search ends here
1098          */
1099         if ((error = xlog_find_verify_cycle(log, start_blk,
1100                                          (int)num_scan_bblks, 0, &new_blk)))
1101                 goto bp_err;
1102         if (new_blk != -1)
1103                 last_blk = new_blk;
1104
1105         /*
1106          * Potentially backup over partial log record write.  We don't need
1107          * to search the end of the log because we know it is zero.
1108          */
1109         if ((error = xlog_find_verify_log_record(log, start_blk,
1110                                 &last_blk, 0)) == -1) {
1111             error = XFS_ERROR(EIO);
1112             goto bp_err;
1113         } else if (error)
1114             goto bp_err;
1115
1116         *blk_no = last_blk;
1117 bp_err:
1118         xlog_put_bp(bp);
1119         if (error)
1120                 return error;
1121         return -1;
1122 }
1123
1124 /*
1125  * These are simple subroutines used by xlog_clear_stale_blocks() below
1126  * to initialize a buffer full of empty log record headers and write
1127  * them into the log.
1128  */
1129 STATIC void
1130 xlog_add_record(
1131         xlog_t                  *log,
1132         xfs_caddr_t             buf,
1133         int                     cycle,
1134         int                     block,
1135         int                     tail_cycle,
1136         int                     tail_block)
1137 {
1138         xlog_rec_header_t       *recp = (xlog_rec_header_t *)buf;
1139
1140         memset(buf, 0, BBSIZE);
1141         recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
1142         recp->h_cycle = cpu_to_be32(cycle);
1143         recp->h_version = cpu_to_be32(
1144                         xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
1145         recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block));
1146         recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block));
1147         recp->h_fmt = cpu_to_be32(XLOG_FMT);
1148         memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
1149 }
1150
1151 STATIC int
1152 xlog_write_log_records(
1153         xlog_t          *log,
1154         int             cycle,
1155         int             start_block,
1156         int             blocks,
1157         int             tail_cycle,
1158         int             tail_block)
1159 {
1160         xfs_caddr_t     offset;
1161         xfs_buf_t       *bp;
1162         int             balign, ealign;
1163         int             sectbb = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, 1);
1164         int             end_block = start_block + blocks;
1165         int             bufblks;
1166         int             error = 0;
1167         int             i, j = 0;
1168
1169         bufblks = 1 << ffs(blocks);
1170         while (!(bp = xlog_get_bp(log, bufblks))) {
1171                 bufblks >>= 1;
1172                 if (bufblks <= log->l_sectbb_log)
1173                         return ENOMEM;
1174         }
1175
1176         /* We may need to do a read at the start to fill in part of
1177          * the buffer in the starting sector not covered by the first
1178          * write below.
1179          */
1180         balign = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, start_block);
1181         if (balign != start_block) {
1182                 error = xlog_bread_noalign(log, start_block, 1, bp);
1183                 if (error)
1184                         goto out_put_bp;
1185
1186                 j = start_block - balign;
1187         }
1188
1189         for (i = start_block; i < end_block; i += bufblks) {
1190                 int             bcount, endcount;
1191
1192                 bcount = min(bufblks, end_block - start_block);
1193                 endcount = bcount - j;
1194
1195                 /* We may need to do a read at the end to fill in part of
1196                  * the buffer in the final sector not covered by the write.
1197                  * If this is the same sector as the above read, skip it.
1198                  */
1199                 ealign = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, end_block);
1200                 if (j == 0 && (start_block + endcount > ealign)) {
1201                         offset = XFS_BUF_PTR(bp);
1202                         balign = BBTOB(ealign - start_block);
1203                         error = XFS_BUF_SET_PTR(bp, offset + balign,
1204                                                 BBTOB(sectbb));
1205                         if (error)
1206                                 break;
1207
1208                         error = xlog_bread_noalign(log, ealign, sectbb, bp);
1209                         if (error)
1210                                 break;
1211
1212                         error = XFS_BUF_SET_PTR(bp, offset, bufblks);
1213                         if (error)
1214                                 break;
1215                 }
1216
1217                 offset = xlog_align(log, start_block, endcount, bp);
1218                 for (; j < endcount; j++) {
1219                         xlog_add_record(log, offset, cycle, i+j,
1220                                         tail_cycle, tail_block);
1221                         offset += BBSIZE;
1222                 }
1223                 error = xlog_bwrite(log, start_block, endcount, bp);
1224                 if (error)
1225                         break;
1226                 start_block += endcount;
1227                 j = 0;
1228         }
1229
1230  out_put_bp:
1231         xlog_put_bp(bp);
1232         return error;
1233 }
1234
1235 /*
1236  * This routine is called to blow away any incomplete log writes out
1237  * in front of the log head.  We do this so that we won't become confused
1238  * if we come up, write only a little bit more, and then crash again.
1239  * If we leave the partial log records out there, this situation could
1240  * cause us to think those partial writes are valid blocks since they
1241  * have the current cycle number.  We get rid of them by overwriting them
1242  * with empty log records with the old cycle number rather than the
1243  * current one.
1244  *
1245  * The tail lsn is passed in rather than taken from
1246  * the log so that we will not write over the unmount record after a
1247  * clean unmount in a 512 block log.  Doing so would leave the log without
1248  * any valid log records in it until a new one was written.  If we crashed
1249  * during that time we would not be able to recover.
1250  */
1251 STATIC int
1252 xlog_clear_stale_blocks(
1253         xlog_t          *log,
1254         xfs_lsn_t       tail_lsn)
1255 {
1256         int             tail_cycle, head_cycle;
1257         int             tail_block, head_block;
1258         int             tail_distance, max_distance;
1259         int             distance;
1260         int             error;
1261
1262         tail_cycle = CYCLE_LSN(tail_lsn);
1263         tail_block = BLOCK_LSN(tail_lsn);
1264         head_cycle = log->l_curr_cycle;
1265         head_block = log->l_curr_block;
1266
1267         /*
1268          * Figure out the distance between the new head of the log
1269          * and the tail.  We want to write over any blocks beyond the
1270          * head that we may have written just before the crash, but
1271          * we don't want to overwrite the tail of the log.
1272          */
1273         if (head_cycle == tail_cycle) {
1274                 /*
1275                  * The tail is behind the head in the physical log,
1276                  * so the distance from the head to the tail is the
1277                  * distance from the head to the end of the log plus
1278                  * the distance from the beginning of the log to the
1279                  * tail.
1280                  */
1281                 if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
1282                         XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
1283                                          XFS_ERRLEVEL_LOW, log->l_mp);
1284                         return XFS_ERROR(EFSCORRUPTED);
1285                 }
1286                 tail_distance = tail_block + (log->l_logBBsize - head_block);
1287         } else {
1288                 /*
1289                  * The head is behind the tail in the physical log,
1290                  * so the distance from the head to the tail is just
1291                  * the tail block minus the head block.
1292                  */
1293                 if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
1294                         XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
1295                                          XFS_ERRLEVEL_LOW, log->l_mp);
1296                         return XFS_ERROR(EFSCORRUPTED);
1297                 }
1298                 tail_distance = tail_block - head_block;
1299         }
1300
1301         /*
1302          * If the head is right up against the tail, we can't clear
1303          * anything.
1304          */
1305         if (tail_distance <= 0) {
1306                 ASSERT(tail_distance == 0);
1307                 return 0;
1308         }
1309
1310         max_distance = XLOG_TOTAL_REC_SHIFT(log);
1311         /*
1312          * Take the smaller of the maximum amount of outstanding I/O
1313          * we could have and the distance to the tail to clear out.
1314          * We take the smaller so that we don't overwrite the tail and
1315          * we don't waste all day writing from the head to the tail
1316          * for no reason.
1317          */
1318         max_distance = MIN(max_distance, tail_distance);
1319
1320         if ((head_block + max_distance) <= log->l_logBBsize) {
1321                 /*
1322                  * We can stomp all the blocks we need to without
1323                  * wrapping around the end of the log.  Just do it
1324                  * in a single write.  Use the cycle number of the
1325                  * current cycle minus one so that the log will look like:
1326                  *     n ... | n - 1 ...
1327                  */
1328                 error = xlog_write_log_records(log, (head_cycle - 1),
1329                                 head_block, max_distance, tail_cycle,
1330                                 tail_block);
1331                 if (error)
1332                         return error;
1333         } else {
1334                 /*
1335                  * We need to wrap around the end of the physical log in
1336                  * order to clear all the blocks.  Do it in two separate
1337                  * I/Os.  The first write should be from the head to the
1338                  * end of the physical log, and it should use the current
1339                  * cycle number minus one just like above.
1340                  */
1341                 distance = log->l_logBBsize - head_block;
1342                 error = xlog_write_log_records(log, (head_cycle - 1),
1343                                 head_block, distance, tail_cycle,
1344                                 tail_block);
1345
1346                 if (error)
1347                         return error;
1348
1349                 /*
1350                  * Now write the blocks at the start of the physical log.
1351                  * This writes the remainder of the blocks we want to clear.
1352                  * It uses the current cycle number since we're now on the
1353                  * same cycle as the head so that we get:
1354                  *    n ... n ... | n - 1 ...
1355                  *    ^^^^^ blocks we're writing
1356                  */
1357                 distance = max_distance - (log->l_logBBsize - head_block);
1358                 error = xlog_write_log_records(log, head_cycle, 0, distance,
1359                                 tail_cycle, tail_block);
1360                 if (error)
1361                         return error;
1362         }
1363
1364         return 0;
1365 }
1366
1367 /******************************************************************************
1368  *
1369  *              Log recover routines
1370  *
1371  ******************************************************************************
1372  */
1373
1374 STATIC xlog_recover_t *
1375 xlog_recover_find_tid(
1376         xlog_recover_t          *q,
1377         xlog_tid_t              tid)
1378 {
1379         xlog_recover_t          *p = q;
1380
1381         while (p != NULL) {
1382                 if (p->r_log_tid == tid)
1383                     break;
1384                 p = p->r_next;
1385         }
1386         return p;
1387 }
1388
1389 STATIC void
1390 xlog_recover_put_hashq(
1391         xlog_recover_t          **q,
1392         xlog_recover_t          *trans)
1393 {
1394         trans->r_next = *q;
1395         *q = trans;
1396 }
1397
1398 STATIC void
1399 xlog_recover_add_item(
1400         xlog_recover_item_t     **itemq)
1401 {
1402         xlog_recover_item_t     *item;
1403
1404         item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
1405         xlog_recover_insert_item_backq(itemq, item);
1406 }
1407
1408 STATIC int
1409 xlog_recover_add_to_cont_trans(
1410         xlog_recover_t          *trans,
1411         xfs_caddr_t             dp,
1412         int                     len)
1413 {
1414         xlog_recover_item_t     *item;
1415         xfs_caddr_t             ptr, old_ptr;
1416         int                     old_len;
1417
1418         item = trans->r_itemq;
1419         if (item == NULL) {
1420                 /* finish copying rest of trans header */
1421                 xlog_recover_add_item(&trans->r_itemq);
1422                 ptr = (xfs_caddr_t) &trans->r_theader +
1423                                 sizeof(xfs_trans_header_t) - len;
1424                 memcpy(ptr, dp, len); /* d, s, l */
1425                 return 0;
1426         }
1427         item = item->ri_prev;
1428
1429         old_ptr = item->ri_buf[item->ri_cnt-1].i_addr;
1430         old_len = item->ri_buf[item->ri_cnt-1].i_len;
1431
1432         ptr = kmem_realloc(old_ptr, len+old_len, old_len, 0u);
1433         memcpy(&ptr[old_len], dp, len); /* d, s, l */
1434         item->ri_buf[item->ri_cnt-1].i_len += len;
1435         item->ri_buf[item->ri_cnt-1].i_addr = ptr;
1436         return 0;
1437 }
1438
1439 /*
1440  * The next region to add is the start of a new region.  It could be
1441  * a whole region or it could be the first part of a new region.  Because
1442  * of this, the assumption here is that the type and size fields of all
1443  * format structures fit into the first 32 bits of the structure.
1444  *
1445  * This works because all regions must be 32 bit aligned.  Therefore, we
1446  * either have both fields or we have neither field.  In the case we have
1447  * neither field, the data part of the region is zero length.  We only have
1448  * a log_op_header and can throw away the header since a new one will appear
1449  * later.  If we have at least 4 bytes, then we can determine how many regions
1450  * will appear in the current log item.
1451  */
1452 STATIC int
1453 xlog_recover_add_to_trans(
1454         xlog_recover_t          *trans,
1455         xfs_caddr_t             dp,
1456         int                     len)
1457 {
1458         xfs_inode_log_format_t  *in_f;                  /* any will do */
1459         xlog_recover_item_t     *item;
1460         xfs_caddr_t             ptr;
1461
1462         if (!len)
1463                 return 0;
1464         item = trans->r_itemq;
1465         if (item == NULL) {
1466                 /* we need to catch log corruptions here */
1467                 if (*(uint *)dp != XFS_TRANS_HEADER_MAGIC) {
1468                         xlog_warn("XFS: xlog_recover_add_to_trans: "
1469                                   "bad header magic number");
1470                         ASSERT(0);
1471                         return XFS_ERROR(EIO);
1472                 }
1473                 if (len == sizeof(xfs_trans_header_t))
1474                         xlog_recover_add_item(&trans->r_itemq);
1475                 memcpy(&trans->r_theader, dp, len); /* d, s, l */
1476                 return 0;
1477         }
1478
1479         ptr = kmem_alloc(len, KM_SLEEP);
1480         memcpy(ptr, dp, len);
1481         in_f = (xfs_inode_log_format_t *)ptr;
1482
1483         if (item->ri_prev->ri_total != 0 &&
1484              item->ri_prev->ri_total == item->ri_prev->ri_cnt) {
1485                 xlog_recover_add_item(&trans->r_itemq);
1486         }
1487         item = trans->r_itemq;
1488         item = item->ri_prev;
1489
1490         if (item->ri_total == 0) {              /* first region to be added */
1491                 if (in_f->ilf_size == 0 ||
1492                     in_f->ilf_size > XLOG_MAX_REGIONS_IN_ITEM) {
1493                         xlog_warn(
1494         "XFS: bad number of regions (%d) in inode log format",
1495                                   in_f->ilf_size);
1496                         ASSERT(0);
1497                         return XFS_ERROR(EIO);
1498                 }
1499
1500                 item->ri_total = in_f->ilf_size;
1501                 item->ri_buf =
1502                         kmem_zalloc(item->ri_total * sizeof(xfs_log_iovec_t),
1503                                     KM_SLEEP);
1504         }
1505         ASSERT(item->ri_total > item->ri_cnt);
1506         /* Description region is ri_buf[0] */
1507         item->ri_buf[item->ri_cnt].i_addr = ptr;
1508         item->ri_buf[item->ri_cnt].i_len  = len;
1509         item->ri_cnt++;
1510         return 0;
1511 }
1512
1513 STATIC void
1514 xlog_recover_new_tid(
1515         xlog_recover_t          **q,
1516         xlog_tid_t              tid,
1517         xfs_lsn_t               lsn)
1518 {
1519         xlog_recover_t          *trans;
1520
1521         trans = kmem_zalloc(sizeof(xlog_recover_t), KM_SLEEP);
1522         trans->r_log_tid   = tid;
1523         trans->r_lsn       = lsn;
1524         xlog_recover_put_hashq(q, trans);
1525 }
1526
1527 STATIC int
1528 xlog_recover_unlink_tid(
1529         xlog_recover_t          **q,
1530         xlog_recover_t          *trans)
1531 {
1532         xlog_recover_t          *tp;
1533         int                     found = 0;
1534
1535         ASSERT(trans != NULL);
1536         if (trans == *q) {
1537                 *q = (*q)->r_next;
1538         } else {
1539                 tp = *q;
1540                 while (tp) {
1541                         if (tp->r_next == trans) {
1542                                 found = 1;
1543                                 break;
1544                         }
1545                         tp = tp->r_next;
1546                 }
1547                 if (!found) {
1548                         xlog_warn(
1549                              "XFS: xlog_recover_unlink_tid: trans not found");
1550                         ASSERT(0);
1551                         return XFS_ERROR(EIO);
1552                 }
1553                 tp->r_next = tp->r_next->r_next;
1554         }
1555         return 0;
1556 }
1557
1558 STATIC void
1559 xlog_recover_insert_item_backq(
1560         xlog_recover_item_t     **q,
1561         xlog_recover_item_t     *item)
1562 {
1563         if (*q == NULL) {
1564                 item->ri_prev = item->ri_next = item;
1565                 *q = item;
1566         } else {
1567                 item->ri_next           = *q;
1568                 item->ri_prev           = (*q)->ri_prev;
1569                 (*q)->ri_prev           = item;
1570                 item->ri_prev->ri_next  = item;
1571         }
1572 }
1573
1574 STATIC void
1575 xlog_recover_insert_item_frontq(
1576         xlog_recover_item_t     **q,
1577         xlog_recover_item_t     *item)
1578 {
1579         xlog_recover_insert_item_backq(q, item);
1580         *q = item;
1581 }
1582
1583 STATIC int
1584 xlog_recover_reorder_trans(
1585         xlog_recover_t          *trans)
1586 {
1587         xlog_recover_item_t     *first_item, *itemq, *itemq_next;
1588         xfs_buf_log_format_t    *buf_f;
1589         ushort                  flags = 0;
1590
1591         first_item = itemq = trans->r_itemq;
1592         trans->r_itemq = NULL;
1593         do {
1594                 itemq_next = itemq->ri_next;
1595                 buf_f = (xfs_buf_log_format_t *)itemq->ri_buf[0].i_addr;
1596
1597                 switch (ITEM_TYPE(itemq)) {
1598                 case XFS_LI_BUF:
1599                         flags = buf_f->blf_flags;
1600                         if (!(flags & XFS_BLI_CANCEL)) {
1601                                 xlog_recover_insert_item_frontq(&trans->r_itemq,
1602                                                                 itemq);
1603                                 break;
1604                         }
1605                 case XFS_LI_INODE:
1606                 case XFS_LI_DQUOT:
1607                 case XFS_LI_QUOTAOFF:
1608                 case XFS_LI_EFD:
1609                 case XFS_LI_EFI:
1610                         xlog_recover_insert_item_backq(&trans->r_itemq, itemq);
1611                         break;
1612                 default:
1613                         xlog_warn(
1614         "XFS: xlog_recover_reorder_trans: unrecognized type of log operation");
1615                         ASSERT(0);
1616                         return XFS_ERROR(EIO);
1617                 }
1618                 itemq = itemq_next;
1619         } while (first_item != itemq);
1620         return 0;
1621 }
1622
1623 /*
1624  * Build up the table of buf cancel records so that we don't replay
1625  * cancelled data in the second pass.  For buffer records that are
1626  * not cancel records, there is nothing to do here so we just return.
1627  *
1628  * If we get a cancel record which is already in the table, this indicates
1629  * that the buffer was cancelled multiple times.  In order to ensure
1630  * that during pass 2 we keep the record in the table until we reach its
1631  * last occurrence in the log, we keep a reference count in the cancel
1632  * record in the table to tell us how many times we expect to see this
1633  * record during the second pass.
1634  */
1635 STATIC void
1636 xlog_recover_do_buffer_pass1(
1637         xlog_t                  *log,
1638         xfs_buf_log_format_t    *buf_f)
1639 {
1640         xfs_buf_cancel_t        *bcp;
1641         xfs_buf_cancel_t        *nextp;
1642         xfs_buf_cancel_t        *prevp;
1643         xfs_buf_cancel_t        **bucket;
1644         xfs_daddr_t             blkno = 0;
1645         uint                    len = 0;
1646         ushort                  flags = 0;
1647
1648         switch (buf_f->blf_type) {
1649         case XFS_LI_BUF:
1650                 blkno = buf_f->blf_blkno;
1651                 len = buf_f->blf_len;
1652                 flags = buf_f->blf_flags;
1653                 break;
1654         }
1655
1656         /*
1657          * If this isn't a cancel buffer item, then just return.
1658          */
1659         if (!(flags & XFS_BLI_CANCEL))
1660                 return;
1661
1662         /*
1663          * Insert an xfs_buf_cancel record into the hash table of
1664          * them.  If there is already an identical record, bump
1665          * its reference count.
1666          */
1667         bucket = &log->l_buf_cancel_table[(__uint64_t)blkno %
1668                                           XLOG_BC_TABLE_SIZE];
1669         /*
1670          * If the hash bucket is empty then just insert a new record into
1671          * the bucket.
1672          */
1673         if (*bucket == NULL) {
1674                 bcp = (xfs_buf_cancel_t *)kmem_alloc(sizeof(xfs_buf_cancel_t),
1675                                                      KM_SLEEP);
1676                 bcp->bc_blkno = blkno;
1677                 bcp->bc_len = len;
1678                 bcp->bc_refcount = 1;
1679                 bcp->bc_next = NULL;
1680                 *bucket = bcp;
1681                 return;
1682         }
1683
1684         /*
1685          * The hash bucket is not empty, so search for duplicates of our
1686          * record.  If we find one them just bump its refcount.  If not
1687          * then add us at the end of the list.
1688          */
1689         prevp = NULL;
1690         nextp = *bucket;
1691         while (nextp != NULL) {
1692                 if (nextp->bc_blkno == blkno && nextp->bc_len == len) {
1693                         nextp->bc_refcount++;
1694                         return;
1695                 }
1696                 prevp = nextp;
1697                 nextp = nextp->bc_next;
1698         }
1699         ASSERT(prevp != NULL);
1700         bcp = (xfs_buf_cancel_t *)kmem_alloc(sizeof(xfs_buf_cancel_t),
1701                                              KM_SLEEP);
1702         bcp->bc_blkno = blkno;
1703         bcp->bc_len = len;
1704         bcp->bc_refcount = 1;
1705         bcp->bc_next = NULL;
1706         prevp->bc_next = bcp;
1707 }
1708
1709 /*
1710  * Check to see whether the buffer being recovered has a corresponding
1711  * entry in the buffer cancel record table.  If it does then return 1
1712  * so that it will be cancelled, otherwise return 0.  If the buffer is
1713  * actually a buffer cancel item (XFS_BLI_CANCEL is set), then decrement
1714  * the refcount on the entry in the table and remove it from the table
1715  * if this is the last reference.
1716  *
1717  * We remove the cancel record from the table when we encounter its
1718  * last occurrence in the log so that if the same buffer is re-used
1719  * again after its last cancellation we actually replay the changes
1720  * made at that point.
1721  */
1722 STATIC int
1723 xlog_check_buffer_cancelled(
1724         xlog_t                  *log,
1725         xfs_daddr_t             blkno,
1726         uint                    len,
1727         ushort                  flags)
1728 {
1729         xfs_buf_cancel_t        *bcp;
1730         xfs_buf_cancel_t        *prevp;
1731         xfs_buf_cancel_t        **bucket;
1732
1733         if (log->l_buf_cancel_table == NULL) {
1734                 /*
1735                  * There is nothing in the table built in pass one,
1736                  * so this buffer must not be cancelled.
1737                  */
1738                 ASSERT(!(flags & XFS_BLI_CANCEL));
1739                 return 0;
1740         }
1741
1742         bucket = &log->l_buf_cancel_table[(__uint64_t)blkno %
1743                                           XLOG_BC_TABLE_SIZE];
1744         bcp = *bucket;
1745         if (bcp == NULL) {
1746                 /*
1747                  * There is no corresponding entry in the table built
1748                  * in pass one, so this buffer has not been cancelled.
1749                  */
1750                 ASSERT(!(flags & XFS_BLI_CANCEL));
1751                 return 0;
1752         }
1753
1754         /*
1755          * Search for an entry in the buffer cancel table that
1756          * matches our buffer.
1757          */
1758         prevp = NULL;
1759         while (bcp != NULL) {
1760                 if (bcp->bc_blkno == blkno && bcp->bc_len == len) {
1761                         /*
1762                          * We've go a match, so return 1 so that the
1763                          * recovery of this buffer is cancelled.
1764                          * If this buffer is actually a buffer cancel
1765                          * log item, then decrement the refcount on the
1766                          * one in the table and remove it if this is the
1767                          * last reference.
1768                          */
1769                         if (flags & XFS_BLI_CANCEL) {
1770                                 bcp->bc_refcount--;
1771                                 if (bcp->bc_refcount == 0) {
1772                                         if (prevp == NULL) {
1773                                                 *bucket = bcp->bc_next;
1774                                         } else {
1775                                                 prevp->bc_next = bcp->bc_next;
1776                                         }
1777                                         kmem_free(bcp);
1778                                 }
1779                         }
1780                         return 1;
1781                 }
1782                 prevp = bcp;
1783                 bcp = bcp->bc_next;
1784         }
1785         /*
1786          * We didn't find a corresponding entry in the table, so
1787          * return 0 so that the buffer is NOT cancelled.
1788          */
1789         ASSERT(!(flags & XFS_BLI_CANCEL));
1790         return 0;
1791 }
1792
1793 STATIC int
1794 xlog_recover_do_buffer_pass2(
1795         xlog_t                  *log,
1796         xfs_buf_log_format_t    *buf_f)
1797 {
1798         xfs_daddr_t             blkno = 0;
1799         ushort                  flags = 0;
1800         uint                    len = 0;
1801
1802         switch (buf_f->blf_type) {
1803         case XFS_LI_BUF:
1804                 blkno = buf_f->blf_blkno;
1805                 flags = buf_f->blf_flags;
1806                 len = buf_f->blf_len;
1807                 break;
1808         }
1809
1810         return xlog_check_buffer_cancelled(log, blkno, len, flags);
1811 }
1812
1813 /*
1814  * Perform recovery for a buffer full of inodes.  In these buffers,
1815  * the only data which should be recovered is that which corresponds
1816  * to the di_next_unlinked pointers in the on disk inode structures.
1817  * The rest of the data for the inodes is always logged through the
1818  * inodes themselves rather than the inode buffer and is recovered
1819  * in xlog_recover_do_inode_trans().
1820  *
1821  * The only time when buffers full of inodes are fully recovered is
1822  * when the buffer is full of newly allocated inodes.  In this case
1823  * the buffer will not be marked as an inode buffer and so will be
1824  * sent to xlog_recover_do_reg_buffer() below during recovery.
1825  */
1826 STATIC int
1827 xlog_recover_do_inode_buffer(
1828         xfs_mount_t             *mp,
1829         xlog_recover_item_t     *item,
1830         xfs_buf_t               *bp,
1831         xfs_buf_log_format_t    *buf_f)
1832 {
1833         int                     i;
1834         int                     item_index;
1835         int                     bit;
1836         int                     nbits;
1837         int                     reg_buf_offset;
1838         int                     reg_buf_bytes;
1839         int                     next_unlinked_offset;
1840         int                     inodes_per_buf;
1841         xfs_agino_t             *logged_nextp;
1842         xfs_agino_t             *buffer_nextp;
1843         unsigned int            *data_map = NULL;
1844         unsigned int            map_size = 0;
1845
1846         switch (buf_f->blf_type) {
1847         case XFS_LI_BUF:
1848                 data_map = buf_f->blf_data_map;
1849                 map_size = buf_f->blf_map_size;
1850                 break;
1851         }
1852         /*
1853          * Set the variables corresponding to the current region to
1854          * 0 so that we'll initialize them on the first pass through
1855          * the loop.
1856          */
1857         reg_buf_offset = 0;
1858         reg_buf_bytes = 0;
1859         bit = 0;
1860         nbits = 0;
1861         item_index = 0;
1862         inodes_per_buf = XFS_BUF_COUNT(bp) >> mp->m_sb.sb_inodelog;
1863         for (i = 0; i < inodes_per_buf; i++) {
1864                 next_unlinked_offset = (i * mp->m_sb.sb_inodesize) +
1865                         offsetof(xfs_dinode_t, di_next_unlinked);
1866
1867                 while (next_unlinked_offset >=
1868                        (reg_buf_offset + reg_buf_bytes)) {
1869                         /*
1870                          * The next di_next_unlinked field is beyond
1871                          * the current logged region.  Find the next
1872                          * logged region that contains or is beyond
1873                          * the current di_next_unlinked field.
1874                          */
1875                         bit += nbits;
1876                         bit = xfs_next_bit(data_map, map_size, bit);
1877
1878                         /*
1879                          * If there are no more logged regions in the
1880                          * buffer, then we're done.
1881                          */
1882                         if (bit == -1) {
1883                                 return 0;
1884                         }
1885
1886                         nbits = xfs_contig_bits(data_map, map_size,
1887                                                          bit);
1888                         ASSERT(nbits > 0);
1889                         reg_buf_offset = bit << XFS_BLI_SHIFT;
1890                         reg_buf_bytes = nbits << XFS_BLI_SHIFT;
1891                         item_index++;
1892                 }
1893
1894                 /*
1895                  * If the current logged region starts after the current
1896                  * di_next_unlinked field, then move on to the next
1897                  * di_next_unlinked field.
1898                  */
1899                 if (next_unlinked_offset < reg_buf_offset) {
1900                         continue;
1901                 }
1902
1903                 ASSERT(item->ri_buf[item_index].i_addr != NULL);
1904                 ASSERT((item->ri_buf[item_index].i_len % XFS_BLI_CHUNK) == 0);
1905                 ASSERT((reg_buf_offset + reg_buf_bytes) <= XFS_BUF_COUNT(bp));
1906
1907                 /*
1908                  * The current logged region contains a copy of the
1909                  * current di_next_unlinked field.  Extract its value
1910                  * and copy it to the buffer copy.
1911                  */
1912                 logged_nextp = (xfs_agino_t *)
1913                                ((char *)(item->ri_buf[item_index].i_addr) +
1914                                 (next_unlinked_offset - reg_buf_offset));
1915                 if (unlikely(*logged_nextp == 0)) {
1916                         xfs_fs_cmn_err(CE_ALERT, mp,
1917                                 "bad inode buffer log record (ptr = 0x%p, bp = 0x%p).  XFS trying to replay bad (0) inode di_next_unlinked field",
1918                                 item, bp);
1919                         XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
1920                                          XFS_ERRLEVEL_LOW, mp);
1921                         return XFS_ERROR(EFSCORRUPTED);
1922                 }
1923
1924                 buffer_nextp = (xfs_agino_t *)xfs_buf_offset(bp,
1925                                               next_unlinked_offset);
1926                 *buffer_nextp = *logged_nextp;
1927         }
1928
1929         return 0;
1930 }
1931
1932 /*
1933  * Perform a 'normal' buffer recovery.  Each logged region of the
1934  * buffer should be copied over the corresponding region in the
1935  * given buffer.  The bitmap in the buf log format structure indicates
1936  * where to place the logged data.
1937  */
1938 /*ARGSUSED*/
1939 STATIC void
1940 xlog_recover_do_reg_buffer(
1941         xlog_recover_item_t     *item,
1942         xfs_buf_t               *bp,
1943         xfs_buf_log_format_t    *buf_f)
1944 {
1945         int                     i;
1946         int                     bit;
1947         int                     nbits;
1948         unsigned int            *data_map = NULL;
1949         unsigned int            map_size = 0;
1950         int                     error;
1951
1952         switch (buf_f->blf_type) {
1953         case XFS_LI_BUF:
1954                 data_map = buf_f->blf_data_map;
1955                 map_size = buf_f->blf_map_size;
1956                 break;
1957         }
1958         bit = 0;
1959         i = 1;  /* 0 is the buf format structure */
1960         while (1) {
1961                 bit = xfs_next_bit(data_map, map_size, bit);
1962                 if (bit == -1)
1963                         break;
1964                 nbits = xfs_contig_bits(data_map, map_size, bit);
1965                 ASSERT(nbits > 0);
1966                 ASSERT(item->ri_buf[i].i_addr != NULL);
1967                 ASSERT(item->ri_buf[i].i_len % XFS_BLI_CHUNK == 0);
1968                 ASSERT(XFS_BUF_COUNT(bp) >=
1969                        ((uint)bit << XFS_BLI_SHIFT)+(nbits<<XFS_BLI_SHIFT));
1970
1971                 /*
1972                  * Do a sanity check if this is a dquot buffer. Just checking
1973                  * the first dquot in the buffer should do. XXXThis is
1974                  * probably a good thing to do for other buf types also.
1975                  */
1976                 error = 0;
1977                 if (buf_f->blf_flags &
1978                    (XFS_BLI_UDQUOT_BUF|XFS_BLI_PDQUOT_BUF|XFS_BLI_GDQUOT_BUF)) {
1979                         if (item->ri_buf[i].i_addr == NULL) {
1980                                 cmn_err(CE_ALERT,
1981                                         "XFS: NULL dquot in %s.", __func__);
1982                                 goto next;
1983                         }
1984                         if (item->ri_buf[i].i_len < sizeof(xfs_disk_dquot_t)) {
1985                                 cmn_err(CE_ALERT,
1986                                         "XFS: dquot too small (%d) in %s.",
1987                                         item->ri_buf[i].i_len, __func__);
1988                                 goto next;
1989                         }
1990                         error = xfs_qm_dqcheck((xfs_disk_dquot_t *)
1991                                                item->ri_buf[i].i_addr,
1992                                                -1, 0, XFS_QMOPT_DOWARN,
1993                                                "dquot_buf_recover");
1994                         if (error)
1995                                 goto next;
1996                 }
1997
1998                 memcpy(xfs_buf_offset(bp,
1999                         (uint)bit << XFS_BLI_SHIFT),    /* dest */
2000                         item->ri_buf[i].i_addr,         /* source */
2001                         nbits<<XFS_BLI_SHIFT);          /* length */
2002  next:
2003                 i++;
2004                 bit += nbits;
2005         }
2006
2007         /* Shouldn't be any more regions */
2008         ASSERT(i == item->ri_total);
2009 }
2010
2011 /*
2012  * Do some primitive error checking on ondisk dquot data structures.
2013  */
2014 int
2015 xfs_qm_dqcheck(
2016         xfs_disk_dquot_t *ddq,
2017         xfs_dqid_t       id,
2018         uint             type,    /* used only when IO_dorepair is true */
2019         uint             flags,
2020         char             *str)
2021 {
2022         xfs_dqblk_t      *d = (xfs_dqblk_t *)ddq;
2023         int             errs = 0;
2024
2025         /*
2026          * We can encounter an uninitialized dquot buffer for 2 reasons:
2027          * 1. If we crash while deleting the quotainode(s), and those blks got
2028          *    used for user data. This is because we take the path of regular
2029          *    file deletion; however, the size field of quotainodes is never
2030          *    updated, so all the tricks that we play in itruncate_finish
2031          *    don't quite matter.
2032          *
2033          * 2. We don't play the quota buffers when there's a quotaoff logitem.
2034          *    But the allocation will be replayed so we'll end up with an
2035          *    uninitialized quota block.
2036          *
2037          * This is all fine; things are still consistent, and we haven't lost
2038          * any quota information. Just don't complain about bad dquot blks.
2039          */
2040         if (be16_to_cpu(ddq->d_magic) != XFS_DQUOT_MAGIC) {
2041                 if (flags & XFS_QMOPT_DOWARN)
2042                         cmn_err(CE_ALERT,
2043                         "%s : XFS dquot ID 0x%x, magic 0x%x != 0x%x",
2044                         str, id, be16_to_cpu(ddq->d_magic), XFS_DQUOT_MAGIC);
2045                 errs++;
2046         }
2047         if (ddq->d_version != XFS_DQUOT_VERSION) {
2048                 if (flags & XFS_QMOPT_DOWARN)
2049                         cmn_err(CE_ALERT,
2050                         "%s : XFS dquot ID 0x%x, version 0x%x != 0x%x",
2051                         str, id, ddq->d_version, XFS_DQUOT_VERSION);
2052                 errs++;
2053         }
2054
2055         if (ddq->d_flags != XFS_DQ_USER &&
2056             ddq->d_flags != XFS_DQ_PROJ &&
2057             ddq->d_flags != XFS_DQ_GROUP) {
2058                 if (flags & XFS_QMOPT_DOWARN)
2059                         cmn_err(CE_ALERT,
2060                         "%s : XFS dquot ID 0x%x, unknown flags 0x%x",
2061                         str, id, ddq->d_flags);
2062                 errs++;
2063         }
2064
2065         if (id != -1 && id != be32_to_cpu(ddq->d_id)) {
2066                 if (flags & XFS_QMOPT_DOWARN)
2067                         cmn_err(CE_ALERT,
2068                         "%s : ondisk-dquot 0x%p, ID mismatch: "
2069                         "0x%x expected, found id 0x%x",
2070                         str, ddq, id, be32_to_cpu(ddq->d_id));
2071                 errs++;
2072         }
2073
2074         if (!errs && ddq->d_id) {
2075                 if (ddq->d_blk_softlimit &&
2076                     be64_to_cpu(ddq->d_bcount) >=
2077                                 be64_to_cpu(ddq->d_blk_softlimit)) {
2078                         if (!ddq->d_btimer) {
2079                                 if (flags & XFS_QMOPT_DOWARN)
2080                                         cmn_err(CE_ALERT,
2081                                         "%s : Dquot ID 0x%x (0x%p) "
2082                                         "BLK TIMER NOT STARTED",
2083                                         str, (int)be32_to_cpu(ddq->d_id), ddq);
2084                                 errs++;
2085                         }
2086                 }
2087                 if (ddq->d_ino_softlimit &&
2088                     be64_to_cpu(ddq->d_icount) >=
2089                                 be64_to_cpu(ddq->d_ino_softlimit)) {
2090                         if (!ddq->d_itimer) {
2091                                 if (flags & XFS_QMOPT_DOWARN)
2092                                         cmn_err(CE_ALERT,
2093                                         "%s : Dquot ID 0x%x (0x%p) "
2094                                         "INODE TIMER NOT STARTED",
2095                                         str, (int)be32_to_cpu(ddq->d_id), ddq);
2096                                 errs++;
2097                         }
2098                 }
2099                 if (ddq->d_rtb_softlimit &&
2100                     be64_to_cpu(ddq->d_rtbcount) >=
2101                                 be64_to_cpu(ddq->d_rtb_softlimit)) {
2102                         if (!ddq->d_rtbtimer) {
2103                                 if (flags & XFS_QMOPT_DOWARN)
2104                                         cmn_err(CE_ALERT,
2105                                         "%s : Dquot ID 0x%x (0x%p) "
2106                                         "RTBLK TIMER NOT STARTED",
2107                                         str, (int)be32_to_cpu(ddq->d_id), ddq);
2108                                 errs++;
2109                         }
2110                 }
2111         }
2112
2113         if (!errs || !(flags & XFS_QMOPT_DQREPAIR))
2114                 return errs;
2115
2116         if (flags & XFS_QMOPT_DOWARN)
2117                 cmn_err(CE_NOTE, "Re-initializing dquot ID 0x%x", id);
2118
2119         /*
2120          * Typically, a repair is only requested by quotacheck.
2121          */
2122         ASSERT(id != -1);
2123         ASSERT(flags & XFS_QMOPT_DQREPAIR);
2124         memset(d, 0, sizeof(xfs_dqblk_t));
2125
2126         d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
2127         d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
2128         d->dd_diskdq.d_flags = type;
2129         d->dd_diskdq.d_id = cpu_to_be32(id);
2130
2131         return errs;
2132 }
2133
2134 /*
2135  * Perform a dquot buffer recovery.
2136  * Simple algorithm: if we have found a QUOTAOFF logitem of the same type
2137  * (ie. USR or GRP), then just toss this buffer away; don't recover it.
2138  * Else, treat it as a regular buffer and do recovery.
2139  */
2140 STATIC void
2141 xlog_recover_do_dquot_buffer(
2142         xfs_mount_t             *mp,
2143         xlog_t                  *log,
2144         xlog_recover_item_t     *item,
2145         xfs_buf_t               *bp,
2146         xfs_buf_log_format_t    *buf_f)
2147 {
2148         uint                    type;
2149
2150         /*
2151          * Filesystems are required to send in quota flags at mount time.
2152          */
2153         if (mp->m_qflags == 0) {
2154                 return;
2155         }
2156
2157         type = 0;
2158         if (buf_f->blf_flags & XFS_BLI_UDQUOT_BUF)
2159                 type |= XFS_DQ_USER;
2160         if (buf_f->blf_flags & XFS_BLI_PDQUOT_BUF)
2161                 type |= XFS_DQ_PROJ;
2162         if (buf_f->blf_flags & XFS_BLI_GDQUOT_BUF)
2163                 type |= XFS_DQ_GROUP;
2164         /*
2165          * This type of quotas was turned off, so ignore this buffer
2166          */
2167         if (log->l_quotaoffs_flag & type)
2168                 return;
2169
2170         xlog_recover_do_reg_buffer(item, bp, buf_f);
2171 }
2172
2173 /*
2174  * This routine replays a modification made to a buffer at runtime.
2175  * There are actually two types of buffer, regular and inode, which
2176  * are handled differently.  Inode buffers are handled differently
2177  * in that we only recover a specific set of data from them, namely
2178  * the inode di_next_unlinked fields.  This is because all other inode
2179  * data is actually logged via inode records and any data we replay
2180  * here which overlaps that may be stale.
2181  *
2182  * When meta-data buffers are freed at run time we log a buffer item
2183  * with the XFS_BLI_CANCEL bit set to indicate that previous copies
2184  * of the buffer in the log should not be replayed at recovery time.
2185  * This is so that if the blocks covered by the buffer are reused for
2186  * file data before we crash we don't end up replaying old, freed
2187  * meta-data into a user's file.
2188  *
2189  * To handle the cancellation of buffer log items, we make two passes
2190  * over the log during recovery.  During the first we build a table of
2191  * those buffers which have been cancelled, and during the second we
2192  * only replay those buffers which do not have corresponding cancel
2193  * records in the table.  See xlog_recover_do_buffer_pass[1,2] above
2194  * for more details on the implementation of the table of cancel records.
2195  */
2196 STATIC int
2197 xlog_recover_do_buffer_trans(
2198         xlog_t                  *log,
2199         xlog_recover_item_t     *item,
2200         int                     pass)
2201 {
2202         xfs_buf_log_format_t    *buf_f;
2203         xfs_mount_t             *mp;
2204         xfs_buf_t               *bp;
2205         int                     error;
2206         int                     cancel;
2207         xfs_daddr_t             blkno;
2208         int                     len;
2209         ushort                  flags;
2210         uint                    buf_flags;
2211
2212         buf_f = (xfs_buf_log_format_t *)item->ri_buf[0].i_addr;
2213
2214         if (pass == XLOG_RECOVER_PASS1) {
2215                 /*
2216                  * In this pass we're only looking for buf items
2217                  * with the XFS_BLI_CANCEL bit set.
2218                  */
2219                 xlog_recover_do_buffer_pass1(log, buf_f);
2220                 return 0;
2221         } else {
2222                 /*
2223                  * In this pass we want to recover all the buffers
2224                  * which have not been cancelled and are not
2225                  * cancellation buffers themselves.  The routine
2226                  * we call here will tell us whether or not to
2227                  * continue with the replay of this buffer.
2228                  */
2229                 cancel = xlog_recover_do_buffer_pass2(log, buf_f);
2230                 if (cancel) {
2231                         return 0;
2232                 }
2233         }
2234         switch (buf_f->blf_type) {
2235         case XFS_LI_BUF:
2236                 blkno = buf_f->blf_blkno;
2237                 len = buf_f->blf_len;
2238                 flags = buf_f->blf_flags;
2239                 break;
2240         default:
2241                 xfs_fs_cmn_err(CE_ALERT, log->l_mp,
2242                         "xfs_log_recover: unknown buffer type 0x%x, logdev %s",
2243                         buf_f->blf_type, log->l_mp->m_logname ?
2244                         log->l_mp->m_logname : "internal");
2245                 XFS_ERROR_REPORT("xlog_recover_do_buffer_trans",
2246                                  XFS_ERRLEVEL_LOW, log->l_mp);
2247                 return XFS_ERROR(EFSCORRUPTED);
2248         }
2249
2250         mp = log->l_mp;
2251         buf_flags = XFS_BUF_LOCK;
2252         if (!(flags & XFS_BLI_INODE_BUF))
2253                 buf_flags |= XFS_BUF_MAPPED;
2254
2255         bp = xfs_buf_read(mp->m_ddev_targp, blkno, len, buf_flags);
2256         if (XFS_BUF_ISERROR(bp)) {
2257                 xfs_ioerror_alert("xlog_recover_do..(read#1)", log->l_mp,
2258                                   bp, blkno);
2259                 error = XFS_BUF_GETERROR(bp);
2260                 xfs_buf_relse(bp);
2261                 return error;
2262         }
2263
2264         error = 0;
2265         if (flags & XFS_BLI_INODE_BUF) {
2266                 error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
2267         } else if (flags &
2268                   (XFS_BLI_UDQUOT_BUF|XFS_BLI_PDQUOT_BUF|XFS_BLI_GDQUOT_BUF)) {
2269                 xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
2270         } else {
2271                 xlog_recover_do_reg_buffer(item, bp, buf_f);
2272         }
2273         if (error)
2274                 return XFS_ERROR(error);
2275
2276         /*
2277          * Perform delayed write on the buffer.  Asynchronous writes will be
2278          * slower when taking into account all the buffers to be flushed.
2279          *
2280          * Also make sure that only inode buffers with good sizes stay in
2281          * the buffer cache.  The kernel moves inodes in buffers of 1 block
2282          * or XFS_INODE_CLUSTER_SIZE bytes, whichever is bigger.  The inode
2283          * buffers in the log can be a different size if the log was generated
2284          * by an older kernel using unclustered inode buffers or a newer kernel
2285          * running with a different inode cluster size.  Regardless, if the
2286          * the inode buffer size isn't MAX(blocksize, XFS_INODE_CLUSTER_SIZE)
2287          * for *our* value of XFS_INODE_CLUSTER_SIZE, then we need to keep
2288          * the buffer out of the buffer cache so that the buffer won't
2289          * overlap with future reads of those inodes.
2290          */
2291         if (XFS_DINODE_MAGIC ==
2292             be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
2293             (XFS_BUF_COUNT(bp) != MAX(log->l_mp->m_sb.sb_blocksize,
2294                         (__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {
2295                 XFS_BUF_STALE(bp);
2296                 error = xfs_bwrite(mp, bp);
2297         } else {
2298                 ASSERT(bp->b_mount == NULL || bp->b_mount == mp);
2299                 bp->b_mount = mp;
2300                 XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
2301                 xfs_bdwrite(mp, bp);
2302         }
2303
2304         return (error);
2305 }
2306
2307 STATIC int
2308 xlog_recover_do_inode_trans(
2309         xlog_t                  *log,
2310         xlog_recover_item_t     *item,
2311         int                     pass)
2312 {
2313         xfs_inode_log_format_t  *in_f;
2314         xfs_mount_t             *mp;
2315         xfs_buf_t               *bp;
2316         xfs_dinode_t            *dip;
2317         xfs_ino_t               ino;
2318         int                     len;
2319         xfs_caddr_t             src;
2320         xfs_caddr_t             dest;
2321         int                     error;
2322         int                     attr_index;
2323         uint                    fields;
2324         xfs_icdinode_t          *dicp;
2325         int                     need_free = 0;
2326
2327         if (pass == XLOG_RECOVER_PASS1) {
2328                 return 0;
2329         }
2330
2331         if (item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t)) {
2332                 in_f = (xfs_inode_log_format_t *)item->ri_buf[0].i_addr;
2333         } else {
2334                 in_f = (xfs_inode_log_format_t *)kmem_alloc(
2335                         sizeof(xfs_inode_log_format_t), KM_SLEEP);
2336                 need_free = 1;
2337                 error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
2338                 if (error)
2339                         goto error;
2340         }
2341         ino = in_f->ilf_ino;
2342         mp = log->l_mp;
2343
2344         /*
2345          * Inode buffers can be freed, look out for it,
2346          * and do not replay the inode.
2347          */
2348         if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno,
2349                                         in_f->ilf_len, 0)) {
2350                 error = 0;
2351                 goto error;
2352         }
2353
2354         bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len,
2355                           XFS_BUF_LOCK);
2356         if (XFS_BUF_ISERROR(bp)) {
2357                 xfs_ioerror_alert("xlog_recover_do..(read#2)", mp,
2358                                   bp, in_f->ilf_blkno);
2359                 error = XFS_BUF_GETERROR(bp);
2360                 xfs_buf_relse(bp);
2361                 goto error;
2362         }
2363         error = 0;
2364         ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
2365         dip = (xfs_dinode_t *)xfs_buf_offset(bp, in_f->ilf_boffset);
2366
2367         /*
2368          * Make sure the place we're flushing out to really looks
2369          * like an inode!
2370          */
2371         if (unlikely(be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC)) {
2372                 xfs_buf_relse(bp);
2373                 xfs_fs_cmn_err(CE_ALERT, mp,
2374                         "xfs_inode_recover: Bad inode magic number, dino ptr = 0x%p, dino bp = 0x%p, ino = %Ld",
2375                         dip, bp, ino);
2376                 XFS_ERROR_REPORT("xlog_recover_do_inode_trans(1)",
2377                                  XFS_ERRLEVEL_LOW, mp);
2378                 error = EFSCORRUPTED;
2379                 goto error;
2380         }
2381         dicp = (xfs_icdinode_t *)(item->ri_buf[1].i_addr);
2382         if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) {
2383                 xfs_buf_relse(bp);
2384                 xfs_fs_cmn_err(CE_ALERT, mp,
2385                         "xfs_inode_recover: Bad inode log record, rec ptr 0x%p, ino %Ld",
2386                         item, ino);
2387                 XFS_ERROR_REPORT("xlog_recover_do_inode_trans(2)",
2388                                  XFS_ERRLEVEL_LOW, mp);
2389                 error = EFSCORRUPTED;
2390                 goto error;
2391         }
2392
2393         /* Skip replay when the on disk inode is newer than the log one */
2394         if (dicp->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
2395                 /*
2396                  * Deal with the wrap case, DI_MAX_FLUSH is less
2397                  * than smaller numbers
2398                  */
2399                 if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
2400                     dicp->di_flushiter < (DI_MAX_FLUSH >> 1)) {
2401                         /* do nothing */
2402                 } else {
2403                         xfs_buf_relse(bp);
2404                         error = 0;
2405                         goto error;
2406                 }
2407         }
2408         /* Take the opportunity to reset the flush iteration count */
2409         dicp->di_flushiter = 0;
2410
2411         if (unlikely((dicp->di_mode & S_IFMT) == S_IFREG)) {
2412                 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2413                     (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
2414                         XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(3)",
2415                                          XFS_ERRLEVEL_LOW, mp, dicp);
2416                         xfs_buf_relse(bp);
2417                         xfs_fs_cmn_err(CE_ALERT, mp,
2418                                 "xfs_inode_recover: Bad regular inode log record, rec ptr 0x%p, ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2419                                 item, dip, bp, ino);
2420                         error = EFSCORRUPTED;
2421                         goto error;
2422                 }
2423         } else if (unlikely((dicp->di_mode & S_IFMT) == S_IFDIR)) {
2424                 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2425                     (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
2426                     (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
2427                         XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(4)",
2428                                              XFS_ERRLEVEL_LOW, mp, dicp);
2429                         xfs_buf_relse(bp);
2430                         xfs_fs_cmn_err(CE_ALERT, mp,
2431                                 "xfs_inode_recover: Bad dir inode log record, rec ptr 0x%p, ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2432                                 item, dip, bp, ino);
2433                         error = EFSCORRUPTED;
2434                         goto error;
2435                 }
2436         }
2437         if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){
2438                 XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(5)",
2439                                      XFS_ERRLEVEL_LOW, mp, dicp);
2440                 xfs_buf_relse(bp);
2441                 xfs_fs_cmn_err(CE_ALERT, mp,
2442                         "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",
2443                         item, dip, bp, ino,
2444                         dicp->di_nextents + dicp->di_anextents,
2445                         dicp->di_nblocks);
2446                 error = EFSCORRUPTED;
2447                 goto error;
2448         }
2449         if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
2450                 XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(6)",
2451                                      XFS_ERRLEVEL_LOW, mp, dicp);
2452                 xfs_buf_relse(bp);
2453                 xfs_fs_cmn_err(CE_ALERT, mp,
2454                         "xfs_inode_recover: Bad inode log rec ptr 0x%p, dino ptr 0x%p, dino bp 0x%p, ino %Ld, forkoff 0x%x",
2455                         item, dip, bp, ino, dicp->di_forkoff);
2456                 error = EFSCORRUPTED;
2457                 goto error;
2458         }
2459         if (unlikely(item->ri_buf[1].i_len > sizeof(struct xfs_icdinode))) {
2460                 XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(7)",
2461                                      XFS_ERRLEVEL_LOW, mp, dicp);
2462                 xfs_buf_relse(bp);
2463                 xfs_fs_cmn_err(CE_ALERT, mp,
2464                         "xfs_inode_recover: Bad inode log record length %d, rec ptr 0x%p",
2465                         item->ri_buf[1].i_len, item);
2466                 error = EFSCORRUPTED;
2467                 goto error;
2468         }
2469
2470         /* The core is in in-core format */
2471         xfs_dinode_to_disk(dip, (xfs_icdinode_t *)item->ri_buf[1].i_addr);
2472
2473         /* the rest is in on-disk format */
2474         if (item->ri_buf[1].i_len > sizeof(struct xfs_icdinode)) {
2475                 memcpy((xfs_caddr_t) dip + sizeof(struct xfs_icdinode),
2476                         item->ri_buf[1].i_addr + sizeof(struct xfs_icdinode),
2477                         item->ri_buf[1].i_len  - sizeof(struct xfs_icdinode));
2478         }
2479
2480         fields = in_f->ilf_fields;
2481         switch (fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) {
2482         case XFS_ILOG_DEV:
2483                 xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev);
2484                 break;
2485         case XFS_ILOG_UUID:
2486                 memcpy(XFS_DFORK_DPTR(dip),
2487                        &in_f->ilf_u.ilfu_uuid,
2488                        sizeof(uuid_t));
2489                 break;
2490         }
2491
2492         if (in_f->ilf_size == 2)
2493                 goto write_inode_buffer;
2494         len = item->ri_buf[2].i_len;
2495         src = item->ri_buf[2].i_addr;
2496         ASSERT(in_f->ilf_size <= 4);
2497         ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK));
2498         ASSERT(!(fields & XFS_ILOG_DFORK) ||
2499                (len == in_f->ilf_dsize));
2500
2501         switch (fields & XFS_ILOG_DFORK) {
2502         case XFS_ILOG_DDATA:
2503         case XFS_ILOG_DEXT:
2504                 memcpy(XFS_DFORK_DPTR(dip), src, len);
2505                 break;
2506
2507         case XFS_ILOG_DBROOT:
2508                 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, len,
2509                                  (xfs_bmdr_block_t *)XFS_DFORK_DPTR(dip),
2510                                  XFS_DFORK_DSIZE(dip, mp));
2511                 break;
2512
2513         default:
2514                 /*
2515                  * There are no data fork flags set.
2516                  */
2517                 ASSERT((fields & XFS_ILOG_DFORK) == 0);
2518                 break;
2519         }
2520
2521         /*
2522          * If we logged any attribute data, recover it.  There may or
2523          * may not have been any other non-core data logged in this
2524          * transaction.
2525          */
2526         if (in_f->ilf_fields & XFS_ILOG_AFORK) {
2527                 if (in_f->ilf_fields & XFS_ILOG_DFORK) {
2528                         attr_index = 3;
2529                 } else {
2530                         attr_index = 2;
2531                 }
2532                 len = item->ri_buf[attr_index].i_len;
2533                 src = item->ri_buf[attr_index].i_addr;
2534                 ASSERT(len == in_f->ilf_asize);
2535
2536                 switch (in_f->ilf_fields & XFS_ILOG_AFORK) {
2537                 case XFS_ILOG_ADATA:
2538                 case XFS_ILOG_AEXT:
2539                         dest = XFS_DFORK_APTR(dip);
2540                         ASSERT(len <= XFS_DFORK_ASIZE(dip, mp));
2541                         memcpy(dest, src, len);
2542                         break;
2543
2544                 case XFS_ILOG_ABROOT:
2545                         dest = XFS_DFORK_APTR(dip);
2546                         xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src,
2547                                          len, (xfs_bmdr_block_t*)dest,
2548                                          XFS_DFORK_ASIZE(dip, mp));
2549                         break;
2550
2551                 default:
2552                         xlog_warn("XFS: xlog_recover_do_inode_trans: Invalid flag");
2553                         ASSERT(0);
2554                         xfs_buf_relse(bp);
2555                         error = EIO;
2556                         goto error;
2557                 }
2558         }
2559
2560 write_inode_buffer:
2561         ASSERT(bp->b_mount == NULL || bp->b_mount == mp);
2562         bp->b_mount = mp;
2563         XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
2564         xfs_bdwrite(mp, bp);
2565 error:
2566         if (need_free)
2567                 kmem_free(in_f);
2568         return XFS_ERROR(error);
2569 }
2570
2571 /*
2572  * Recover QUOTAOFF records. We simply make a note of it in the xlog_t
2573  * structure, so that we know not to do any dquot item or dquot buffer recovery,
2574  * of that type.
2575  */
2576 STATIC int
2577 xlog_recover_do_quotaoff_trans(
2578         xlog_t                  *log,
2579         xlog_recover_item_t     *item,
2580         int                     pass)
2581 {
2582         xfs_qoff_logformat_t    *qoff_f;
2583
2584         if (pass == XLOG_RECOVER_PASS2) {
2585                 return (0);
2586         }
2587
2588         qoff_f = (xfs_qoff_logformat_t *)item->ri_buf[0].i_addr;
2589         ASSERT(qoff_f);
2590
2591         /*
2592          * The logitem format's flag tells us if this was user quotaoff,
2593          * group/project quotaoff or both.
2594          */
2595         if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
2596                 log->l_quotaoffs_flag |= XFS_DQ_USER;
2597         if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
2598                 log->l_quotaoffs_flag |= XFS_DQ_PROJ;
2599         if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
2600                 log->l_quotaoffs_flag |= XFS_DQ_GROUP;
2601
2602         return (0);
2603 }
2604
2605 /*
2606  * Recover a dquot record
2607  */
2608 STATIC int
2609 xlog_recover_do_dquot_trans(
2610         xlog_t                  *log,
2611         xlog_recover_item_t     *item,
2612         int                     pass)
2613 {
2614         xfs_mount_t             *mp;
2615         xfs_buf_t               *bp;
2616         struct xfs_disk_dquot   *ddq, *recddq;
2617         int                     error;
2618         xfs_dq_logformat_t      *dq_f;
2619         uint                    type;
2620
2621         if (pass == XLOG_RECOVER_PASS1) {
2622                 return 0;
2623         }
2624         mp = log->l_mp;
2625
2626         /*
2627          * Filesystems are required to send in quota flags at mount time.
2628          */
2629         if (mp->m_qflags == 0)
2630                 return (0);
2631
2632         recddq = (xfs_disk_dquot_t *)item->ri_buf[1].i_addr;
2633
2634         if (item->ri_buf[1].i_addr == NULL) {
2635                 cmn_err(CE_ALERT,
2636                         "XFS: NULL dquot in %s.", __func__);
2637                 return XFS_ERROR(EIO);
2638         }
2639         if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
2640                 cmn_err(CE_ALERT,
2641                         "XFS: dquot too small (%d) in %s.",
2642                         item->ri_buf[1].i_len, __func__);
2643                 return XFS_ERROR(EIO);
2644         }
2645
2646         /*
2647          * This type of quotas was turned off, so ignore this record.
2648          */
2649         type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
2650         ASSERT(type);
2651         if (log->l_quotaoffs_flag & type)
2652                 return (0);
2653
2654         /*
2655          * At this point we know that quota was _not_ turned off.
2656          * Since the mount flags are not indicating to us otherwise, this
2657          * must mean that quota is on, and the dquot needs to be replayed.
2658          * Remember that we may not have fully recovered the superblock yet,
2659          * so we can't do the usual trick of looking at the SB quota bits.
2660          *
2661          * The other possibility, of course, is that the quota subsystem was
2662          * removed since the last mount - ENOSYS.
2663          */
2664         dq_f = (xfs_dq_logformat_t *)item->ri_buf[0].i_addr;
2665         ASSERT(dq_f);
2666         if ((error = xfs_qm_dqcheck(recddq,
2667                            dq_f->qlf_id,
2668                            0, XFS_QMOPT_DOWARN,
2669                            "xlog_recover_do_dquot_trans (log copy)"))) {
2670                 return XFS_ERROR(EIO);
2671         }
2672         ASSERT(dq_f->qlf_len == 1);
2673
2674         error = xfs_read_buf(mp, mp->m_ddev_targp,
2675                              dq_f->qlf_blkno,
2676                              XFS_FSB_TO_BB(mp, dq_f->qlf_len),
2677                              0, &bp);
2678         if (error) {
2679                 xfs_ioerror_alert("xlog_recover_do..(read#3)", mp,
2680                                   bp, dq_f->qlf_blkno);
2681                 return error;
2682         }
2683         ASSERT(bp);
2684         ddq = (xfs_disk_dquot_t *)xfs_buf_offset(bp, dq_f->qlf_boffset);
2685
2686         /*
2687          * At least the magic num portion should be on disk because this
2688          * was among a chunk of dquots created earlier, and we did some
2689          * minimal initialization then.
2690          */
2691         if (xfs_qm_dqcheck(ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
2692                            "xlog_recover_do_dquot_trans")) {
2693                 xfs_buf_relse(bp);
2694                 return XFS_ERROR(EIO);
2695         }
2696
2697         memcpy(ddq, recddq, item->ri_buf[1].i_len);
2698
2699         ASSERT(dq_f->qlf_size == 2);
2700         ASSERT(bp->b_mount == NULL || bp->b_mount == mp);
2701         bp->b_mount = mp;
2702         XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
2703         xfs_bdwrite(mp, bp);
2704
2705         return (0);
2706 }
2707
2708 /*
2709  * This routine is called to create an in-core extent free intent
2710  * item from the efi format structure which was logged on disk.
2711  * It allocates an in-core efi, copies the extents from the format
2712  * structure into it, and adds the efi to the AIL with the given
2713  * LSN.
2714  */
2715 STATIC int
2716 xlog_recover_do_efi_trans(
2717         xlog_t                  *log,
2718         xlog_recover_item_t     *item,
2719         xfs_lsn_t               lsn,
2720         int                     pass)
2721 {
2722         int                     error;
2723         xfs_mount_t             *mp;
2724         xfs_efi_log_item_t      *efip;
2725         xfs_efi_log_format_t    *efi_formatp;
2726
2727         if (pass == XLOG_RECOVER_PASS1) {
2728                 return 0;
2729         }
2730
2731         efi_formatp = (xfs_efi_log_format_t *)item->ri_buf[0].i_addr;
2732
2733         mp = log->l_mp;
2734         efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
2735         if ((error = xfs_efi_copy_format(&(item->ri_buf[0]),
2736                                          &(efip->efi_format)))) {
2737                 xfs_efi_item_free(efip);
2738                 return error;
2739         }
2740         efip->efi_next_extent = efi_formatp->efi_nextents;
2741         efip->efi_flags |= XFS_EFI_COMMITTED;
2742
2743         spin_lock(&log->l_ailp->xa_lock);
2744         /*
2745          * xfs_trans_ail_update() drops the AIL lock.
2746          */
2747         xfs_trans_ail_update(log->l_ailp, (xfs_log_item_t *)efip, lsn);
2748         return 0;
2749 }
2750
2751
2752 /*
2753  * This routine is called when an efd format structure is found in
2754  * a committed transaction in the log.  It's purpose is to cancel
2755  * the corresponding efi if it was still in the log.  To do this
2756  * it searches the AIL for the efi with an id equal to that in the
2757  * efd format structure.  If we find it, we remove the efi from the
2758  * AIL and free it.
2759  */
2760 STATIC void
2761 xlog_recover_do_efd_trans(
2762         xlog_t                  *log,
2763         xlog_recover_item_t     *item,
2764         int                     pass)
2765 {
2766         xfs_efd_log_format_t    *efd_formatp;
2767         xfs_efi_log_item_t      *efip = NULL;
2768         xfs_log_item_t          *lip;
2769         __uint64_t              efi_id;
2770         struct xfs_ail_cursor   cur;
2771         struct xfs_ail          *ailp = log->l_ailp;
2772
2773         if (pass == XLOG_RECOVER_PASS1) {
2774                 return;
2775         }
2776
2777         efd_formatp = (xfs_efd_log_format_t *)item->ri_buf[0].i_addr;
2778         ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) +
2779                 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) ||
2780                (item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) +
2781                 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t)))));
2782         efi_id = efd_formatp->efd_efi_id;
2783
2784         /*
2785          * Search for the efi with the id in the efd format structure
2786          * in the AIL.
2787          */
2788         spin_lock(&ailp->xa_lock);
2789         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
2790         while (lip != NULL) {
2791                 if (lip->li_type == XFS_LI_EFI) {
2792                         efip = (xfs_efi_log_item_t *)lip;
2793                         if (efip->efi_format.efi_id == efi_id) {
2794                                 /*
2795                                  * xfs_trans_ail_delete() drops the
2796                                  * AIL lock.
2797                                  */
2798                                 xfs_trans_ail_delete(ailp, lip);
2799                                 xfs_efi_item_free(efip);
2800                                 spin_lock(&ailp->xa_lock);
2801                                 break;
2802                         }
2803                 }
2804                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
2805         }
2806         xfs_trans_ail_cursor_done(ailp, &cur);
2807         spin_unlock(&ailp->xa_lock);
2808 }
2809
2810 /*
2811  * Perform the transaction
2812  *
2813  * If the transaction modifies a buffer or inode, do it now.  Otherwise,
2814  * EFIs and EFDs get queued up by adding entries into the AIL for them.
2815  */
2816 STATIC int
2817 xlog_recover_do_trans(
2818         xlog_t                  *log,
2819         xlog_recover_t          *trans,
2820         int                     pass)
2821 {
2822         int                     error = 0;
2823         xlog_recover_item_t     *item, *first_item;
2824
2825         error = xlog_recover_reorder_trans(trans);
2826         if (error)
2827                 return error;
2828
2829         first_item = item = trans->r_itemq;
2830         do {
2831                 switch (ITEM_TYPE(item)) {
2832                 case XFS_LI_BUF:
2833                         error = xlog_recover_do_buffer_trans(log, item, pass);
2834                         break;
2835                 case XFS_LI_INODE:
2836                         error = xlog_recover_do_inode_trans(log, item, pass);
2837                         break;
2838                 case XFS_LI_EFI:
2839                         error = xlog_recover_do_efi_trans(log, item,
2840                                                           trans->r_lsn, pass);
2841                         break;
2842                 case XFS_LI_EFD:
2843                         xlog_recover_do_efd_trans(log, item, pass);
2844                         error = 0;
2845                         break;
2846                 case XFS_LI_DQUOT:
2847                         error = xlog_recover_do_dquot_trans(log, item, pass);
2848                         break;
2849                 case XFS_LI_QUOTAOFF:
2850                         error = xlog_recover_do_quotaoff_trans(log, item,
2851                                                                pass);
2852                         break;
2853                 default:
2854                         xlog_warn(
2855         "XFS: invalid item type (%d) xlog_recover_do_trans", ITEM_TYPE(item));
2856                         ASSERT(0);
2857                         error = XFS_ERROR(EIO);
2858                         break;
2859                 }
2860
2861                 if (error)
2862                         return error;
2863                 item = item->ri_next;
2864         } while (first_item != item);
2865
2866         return 0;
2867 }
2868
2869 /*
2870  * Free up any resources allocated by the transaction
2871  *
2872  * Remember that EFIs, EFDs, and IUNLINKs are handled later.
2873  */
2874 STATIC void
2875 xlog_recover_free_trans(
2876         xlog_recover_t          *trans)
2877 {
2878         xlog_recover_item_t     *first_item, *item, *free_item;
2879         int                     i;
2880
2881         item = first_item = trans->r_itemq;
2882         do {
2883                 free_item = item;
2884                 item = item->ri_next;
2885                  /* Free the regions in the item. */
2886                 for (i = 0; i < free_item->ri_cnt; i++) {
2887                         kmem_free(free_item->ri_buf[i].i_addr);
2888                 }
2889                 /* Free the item itself */
2890                 kmem_free(free_item->ri_buf);
2891                 kmem_free(free_item);
2892         } while (first_item != item);
2893         /* Free the transaction recover structure */
2894         kmem_free(trans);
2895 }
2896
2897 STATIC int
2898 xlog_recover_commit_trans(
2899         xlog_t                  *log,
2900         xlog_recover_t          **q,
2901         xlog_recover_t          *trans,
2902         int                     pass)
2903 {
2904         int                     error;
2905
2906         if ((error = xlog_recover_unlink_tid(q, trans)))
2907                 return error;
2908         if ((error = xlog_recover_do_trans(log, trans, pass)))
2909                 return error;
2910         xlog_recover_free_trans(trans);                 /* no error */
2911         return 0;
2912 }
2913
2914 STATIC int
2915 xlog_recover_unmount_trans(
2916         xlog_recover_t          *trans)
2917 {
2918         /* Do nothing now */
2919         xlog_warn("XFS: xlog_recover_unmount_trans: Unmount LR");
2920         return 0;
2921 }
2922
2923 /*
2924  * There are two valid states of the r_state field.  0 indicates that the
2925  * transaction structure is in a normal state.  We have either seen the
2926  * start of the transaction or the last operation we added was not a partial
2927  * operation.  If the last operation we added to the transaction was a
2928  * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
2929  *
2930  * NOTE: skip LRs with 0 data length.
2931  */
2932 STATIC int
2933 xlog_recover_process_data(
2934         xlog_t                  *log,
2935         xlog_recover_t          *rhash[],
2936         xlog_rec_header_t       *rhead,
2937         xfs_caddr_t             dp,
2938         int                     pass)
2939 {
2940         xfs_caddr_t             lp;
2941         int                     num_logops;
2942         xlog_op_header_t        *ohead;
2943         xlog_recover_t          *trans;
2944         xlog_tid_t              tid;
2945         int                     error;
2946         unsigned long           hash;
2947         uint                    flags;
2948
2949         lp = dp + be32_to_cpu(rhead->h_len);
2950         num_logops = be32_to_cpu(rhead->h_num_logops);
2951
2952         /* check the log format matches our own - else we can't recover */
2953         if (xlog_header_check_recover(log->l_mp, rhead))
2954                 return (XFS_ERROR(EIO));
2955
2956         while ((dp < lp) && num_logops) {
2957                 ASSERT(dp + sizeof(xlog_op_header_t) <= lp);
2958                 ohead = (xlog_op_header_t *)dp;
2959                 dp += sizeof(xlog_op_header_t);
2960                 if (ohead->oh_clientid != XFS_TRANSACTION &&
2961                     ohead->oh_clientid != XFS_LOG) {
2962                         xlog_warn(
2963                 "XFS: xlog_recover_process_data: bad clientid");
2964                         ASSERT(0);
2965                         return (XFS_ERROR(EIO));
2966                 }
2967                 tid = be32_to_cpu(ohead->oh_tid);
2968                 hash = XLOG_RHASH(tid);
2969                 trans = xlog_recover_find_tid(rhash[hash], tid);
2970                 if (trans == NULL) {               /* not found; add new tid */
2971                         if (ohead->oh_flags & XLOG_START_TRANS)
2972                                 xlog_recover_new_tid(&rhash[hash], tid,
2973                                         be64_to_cpu(rhead->h_lsn));
2974                 } else {
2975                         if (dp + be32_to_cpu(ohead->oh_len) > lp) {
2976                                 xlog_warn(
2977                         "XFS: xlog_recover_process_data: bad length");
2978                                 WARN_ON(1);
2979                                 return (XFS_ERROR(EIO));
2980                         }
2981                         flags = ohead->oh_flags & ~XLOG_END_TRANS;
2982                         if (flags & XLOG_WAS_CONT_TRANS)
2983                                 flags &= ~XLOG_CONTINUE_TRANS;
2984                         switch (flags) {
2985                         case XLOG_COMMIT_TRANS:
2986                                 error = xlog_recover_commit_trans(log,
2987                                                 &rhash[hash], trans, pass);
2988                                 break;
2989                         case XLOG_UNMOUNT_TRANS:
2990                                 error = xlog_recover_unmount_trans(trans);
2991                                 break;
2992                         case XLOG_WAS_CONT_TRANS:
2993                                 error = xlog_recover_add_to_cont_trans(trans,
2994                                                 dp, be32_to_cpu(ohead->oh_len));
2995                                 break;
2996                         case XLOG_START_TRANS:
2997                                 xlog_warn(
2998                         "XFS: xlog_recover_process_data: bad transaction");
2999                                 ASSERT(0);
3000                                 error = XFS_ERROR(EIO);
3001                                 break;
3002                         case 0:
3003                         case XLOG_CONTINUE_TRANS:
3004                                 error = xlog_recover_add_to_trans(trans,
3005                                                 dp, be32_to_cpu(ohead->oh_len));
3006                                 break;
3007                         default:
3008                                 xlog_warn(
3009                         "XFS: xlog_recover_process_data: bad flag");
3010                                 ASSERT(0);
3011                                 error = XFS_ERROR(EIO);
3012                                 break;
3013                         }
3014                         if (error)
3015                                 return error;
3016                 }
3017                 dp += be32_to_cpu(ohead->oh_len);
3018                 num_logops--;
3019         }
3020         return 0;
3021 }
3022
3023 /*
3024  * Process an extent free intent item that was recovered from
3025  * the log.  We need to free the extents that it describes.