| blob | d6e049fdd977d7f70fa831cfdf89d566a7784515 |
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 */
51 #define BLK_AVG(blk1, blk2) ((blk1+blk2) >> 1)
53 STATIC int
56 xfs_daddr_t *);
57 STATIC int
60 xfs_lsn_t);
61 #if defined(DEBUG)
62 STATIC void
65 #else
66 #define xlog_recover_check_summary(log)
67 #endif
68 STATIC int
72 /*
73 * This structure is used during recovery to record the buf log items which
74 * have been canceled and should not be replayed.
75 */
77 xfs_daddr_t bc_blkno;
78 uint bc_len;
81 };
83 /*
84 * Sector aligned buffer routines for buffer create/read/write/access
85 */
87 /*
88 * Verify the given count of basic blocks is valid number of blocks
89 * to specify for an operation involving the given XFS log buffer.
90 * Returns nonzero if the count is valid, 0 otherwise.
91 */
97 {
99 }
101 /*
102 * Allocate a buffer to hold log data. The buffer needs to be able
103 * to map to a range of nbblks basic blocks at any valid (basic
104 * block) offset within the log.
105 */
106 STATIC xfs_buf_t *
110 {
115 nbblks);
118 }
120 /*
121 * We do log I/O in units of log sectors (a power-of-2
122 * multiple of the basic block size), so we round up the
123 * requested size to accommodate the basic blocks required
124 * for complete log sectors.
125 *
126 * In addition, the buffer may be used for a non-sector-
127 * aligned block offset, in which case an I/O of the
128 * requested size could extend beyond the end of the
129 * buffer. If the requested size is only 1 basic block it
130 * will never straddle a sector boundary, so this won't be
131 * an issue. Nor will this be a problem if the log I/O is
132 * done in basic blocks (sector size 1). But otherwise we
133 * extend the buffer by one extra log sector to ensure
134 * there's space to accommodate this possibility.
135 */
144 }
146 STATIC void
149 {
151 }
153 /*
154 * Return the address of the start of the given block number's data
155 * in a log buffer. The buffer covers a log sector-aligned region.
156 */
160 xfs_daddr_t blk_no,
163 {
168 }
171 /*
172 * nbblks should be uint, but oh well. Just want to catch that 32-bit length.
173 */
174 STATIC int
177 xfs_daddr_t blk_no,
180 {
185 nbblks);
188 }
205 }
207 STATIC int
210 xfs_daddr_t blk_no,
214 {
223 }
225 /*
226 * Read at an offset into the buffer. Returns with the buffer in it's original
227 * state regardless of the result of the read.
228 */
229 STATIC int
236 {
247 /* must reset buffer pointer even on error */
252 }
254 /*
255 * Write out the buffer at the given block for the given number of blocks.
256 * The buffer is kept locked across the write and is returned locked.
257 * This can only be used for synchronous log writes.
258 */
259 STATIC int
262 xfs_daddr_t blk_no,
265 {
270 nbblks);
273 }
292 }
294 #ifdef DEBUG
295 /*
296 * dump debug superblock and log record information
297 */
298 STATIC void
302 {
307 }
308 #else
309 #define xlog_header_check_dump(mp, head)
310 #endif
312 /*
313 * check log record header for recovery
314 */
315 STATIC int
319 {
322 /*
323 * IRIX doesn't write the h_fmt field and leaves it zeroed
324 * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
325 * a dirty log created in IRIX.
326 */
341 }
343 }
345 /*
346 * read the head block of the log and check the header
347 */
348 STATIC int
352 {
356 /*
357 * IRIX doesn't write the h_fs_uuid or h_fmt fields. If
358 * h_fs_uuid is null, we assume this log was last mounted
359 * by IRIX and continue.
360 */
368 }
370 }
372 STATIC void
375 {
377 /*
378 * We're not going to bother about retrying
379 * this during recovery. One strike!
380 */
384 SHUTDOWN_META_IO_ERROR);
385 }
386 }
388 /*
389 * On v5 supers, a bli could be attached to update the metadata LSN.
390 * Clean it up.
391 */
398 }
400 /*
401 * This routine finds (to an approximation) the first block in the physical
402 * log which contains the given cycle. It uses a binary search algorithm.
403 * Note that the algorithm can not be perfect because the disk will not
404 * necessarily be perfect.
405 */
406 STATIC int
410 xfs_daddr_t first_blk,
412 uint cycle)
413 {
415 xfs_daddr_t mid_blk;
416 xfs_daddr_t end_blk;
417 uint mid_cycle;
429 else
432 }
439 }
441 /*
442 * Check that a range of blocks does not contain stop_on_cycle_no.
443 * Fill in *new_blk with the block offset where such a block is
444 * found, or with -1 (an invalid block number) if there is no such
445 * block in the range. The scan needs to occur from front to back
446 * and the pointer into the region must be updated since a later
447 * routine will need to perform another test.
448 */
449 STATIC int
452 xfs_daddr_t start_blk,
454 uint stop_on_cycle_no,
456 {
458 uint cycle;
460 xfs_daddr_t bufblks;
464 /*
465 * Greedily allocate a buffer big enough to handle the full
466 * range of basic blocks we'll be examining. If that fails,
467 * try a smaller size. We need to be able to read at least
468 * a log sector, or we're out of luck.
469 */
477 }
493 }
496 }
497 }
501 out:
504 }
506 /*
507 * Potentially backup over partial log record write.
508 *
509 * In the typical case, last_blk is the number of the block directly after
510 * a good log record. Therefore, we subtract one to get the block number
511 * of the last block in the given buffer. extra_bblks contains the number
512 * of blocks we would have read on a previous read. This happens when the
513 * last log record is split over the end of the physical log.
514 *
515 * extra_bblks is the number of blocks potentially verified on a previous
516 * call to this routine.
517 */
518 STATIC int
521 xfs_daddr_t start_blk,
524 {
525 xfs_daddr_t i;
545 }
549 /* valid log record not found */
555 }
561 }
570 }
572 /*
573 * We hit the beginning of the physical log & still no header. Return
574 * to caller. If caller can handle a return of -1, then this routine
575 * will be called again for the end of the physical log.
576 */
580 }
582 /*
583 * We have the final block of the good log (the first block
584 * of the log record _before_ the head. So we check the uuid.
585 */
589 /*
590 * We may have found a log record header before we expected one.
591 * last_blk will be the 1st block # with a given cycle #. We may end
592 * up reading an entire log record. In this case, we don't want to
593 * reset last_blk. Only when last_blk points in the middle of a log
594 * record do we update last_blk.
595 */
601 xhdrs++;
604 }
610 out:
613 }
615 /*
616 * Head is defined to be the point of the log where the next log write
617 * could go. This means that incomplete LR writes at the end are
618 * eliminated when calculating the head. We aren't guaranteed that previous
619 * LR have complete transactions. We only know that a cycle number of
620 * current cycle number -1 won't be present in the log if we start writing
621 * from our current block number.
622 *
623 * last_blk contains the block number of the first block with a given
624 * cycle number.
625 *
626 * Return: zero if normal, non-zero if error.
627 */
628 STATIC int
632 {
638 uint stop_on_cycle;
641 /* Is the end of the log device zeroed? */
646 }
650 /* Is the whole lot zeroed? */
652 /* Linux XFS shouldn't generate totally zeroed logs -
653 * mkfs etc write a dummy unmount record to a fresh
654 * log so we can store the uuid in there
655 */
657 }
660 }
681 /*
682 * If the 1st half cycle number is equal to the last half cycle number,
683 * then the entire log is stamped with the same cycle number. In this
684 * case, head_blk can't be set to zero (which makes sense). The below
685 * math doesn't work out properly with head_blk equal to zero. Instead,
686 * we set it to log_bbnum which is an invalid block number, but this
687 * value makes the math correct. If head_blk doesn't changed through
688 * all the tests below, *head_blk is set to zero at the very end rather
689 * than log_bbnum. In a sense, log_bbnum and zero are the same block
690 * in a circular file.
691 */
693 /*
694 * In this case we believe that the entire log should have
695 * cycle number last_half_cycle. We need to scan backwards
696 * from the end verifying that there are no holes still
697 * containing last_half_cycle - 1. If we find such a hole,
698 * then the start of that hole will be the new head. The
699 * simple case looks like
700 * x | x ... | x - 1 | x
701 * Another case that fits this picture would be
702 * x | x + 1 | x ... | x
703 * In this case the head really is somewhere at the end of the
704 * log, as one of the latest writes at the beginning was
705 * incomplete.
706 * One more case is
707 * x | x + 1 | x ... | x - 1 | x
708 * This is really the combination of the above two cases, and
709 * the head has to end up at the start of the x-1 hole at the
710 * end of the log.
711 *
712 * In the 256k log case, we will read from the beginning to the
713 * end of the log and search for cycle numbers equal to x-1.
714 * We don't worry about the x+1 blocks that we encounter,
715 * because we know that they cannot be the head since the log
716 * started with x.
717 */
721 /*
722 * In this case we want to find the first block with cycle
723 * number matching last_half_cycle. We expect the log to be
724 * some variation on
725 * x + 1 ... | x ... | x
726 * The first block with cycle number x (last_half_cycle) will
727 * be where the new head belongs. First we do a binary search
728 * for the first occurrence of last_half_cycle. The binary
729 * search may not be totally accurate, so then we scan back
730 * from there looking for occurrences of last_half_cycle before
731 * us. If that backwards scan wraps around the beginning of
732 * the log, then we look for occurrences of last_half_cycle - 1
733 * at the end of the log. The cases we're looking for look
734 * like
735 * v binary search stopped here
736 * x + 1 ... | x | x + 1 | x ... | x
737 * ^ but we want to locate this spot
738 * or
739 * <---------> less than scan distance
740 * x + 1 ... | x ... | x - 1 | x
741 * ^ we want to locate this spot
742 */
747 }
749 /*
750 * Now validate the answer. Scan back some number of maximum possible
751 * blocks and make sure each one has the expected cycle number. The
752 * maximum is determined by the total possible amount of buffering
753 * in the in-core log. The following number can be made tighter if
754 * we actually look at the block size of the filesystem.
755 */
758 /*
759 * We are guaranteed that the entire check can be performed
760 * in one buffer.
761 */
770 /*
771 * We are going to scan backwards in the log in two parts.
772 * First we scan the physical end of the log. In this part
773 * of the log, we are looking for blocks with cycle number
774 * last_half_cycle - 1.
775 * If we find one, then we know that the log starts there, as
776 * we've found a hole that didn't get written in going around
777 * the end of the physical log. The simple case for this is
778 * x + 1 ... | x ... | x - 1 | x
779 * <---------> less than scan distance
780 * If all of the blocks at the end of the log have cycle number
781 * last_half_cycle, then we check the blocks at the start of
782 * the log looking for occurrences of last_half_cycle. If we
783 * find one, then our current estimate for the location of the
784 * first occurrence of last_half_cycle is wrong and we move
785 * back to the hole we've found. This case looks like
786 * x + 1 ... | x | x + 1 | x ...
787 * ^ binary search stopped here
788 * Another case we need to handle that only occurs in 256k
789 * logs is
790 * x + 1 ... | x ... | x+1 | x ...
791 * ^ binary search stops here
792 * In a 256k log, the scan at the end of the log will see the
793 * x + 1 blocks. We need to skip past those since that is
794 * certainly not the head of the log. By searching for
795 * last_half_cycle-1 we accomplish that.
796 */
807 }
809 /*
810 * Scan beginning of log now. The last part of the physical
811 * log is good. This scan needs to verify that it doesn't find
812 * the last_half_cycle.
813 */
822 }
824 validate_head:
825 /*
826 * Now we need to make sure head_blk is not pointing to a block in
827 * the middle of a log record.
828 */
833 /* start ptr at last block ptr before head_blk */
846 /* We hit the beginning of the log during our search */
862 }
867 else
869 /*
870 * When returning here, we have a good block number. Bad block
871 * means that during a previous crash, we didn't have a clean break
872 * from cycle number N to cycle number N-1. In this case, we need
873 * to find the first block with cycle number N-1.
874 */
877 bp_err:
883 }
885 /*
886 * Seek backwards in the log for log record headers.
887 *
888 * Given a starting log block, walk backwards until we find the provided number
889 * of records or hit the provided tail block. The return value is the number of
890 * records encountered or a negative error code. The log block and buffer
891 * pointer of the last record seen are returned in rblk and rhead respectively.
892 */
893 STATIC int
896 xfs_daddr_t head_blk,
897 xfs_daddr_t tail_blk,
903 {
908 xfs_daddr_t end_blk;
912 /*
913 * Walk backwards from the head block until we hit the tail or the first
914 * block in the log.
915 */
927 }
928 }
930 /*
931 * If we haven't hit the tail block or the log record header count,
932 * start looking again from the end of the physical log. Note that
933 * callers can pass head == tail if the tail is not yet known.
934 */
948 }
949 }
950 }
954 out_error:
956 }
958 /*
959 * Seek forward in the log for log record headers.
960 *
961 * Given head and tail blocks, walk forward from the tail block until we find
962 * the provided number of records or hit the head block. The return value is the
963 * number of records encountered or a negative error code. The log block and
964 * buffer pointer of the last record seen are returned in rblk and rhead
965 * respectively.
966 */
967 STATIC int
970 xfs_daddr_t head_blk,
971 xfs_daddr_t tail_blk,
977 {
982 xfs_daddr_t end_blk;
986 /*
987 * Walk forward from the tail block until we hit the head or the last
988 * block in the log.
989 */
1001 }
1002 }
1004 /*
1005 * If we haven't hit the head block or the log record header count,
1006 * start looking again from the start of the physical log.
1007 */
1021 }
1022 }
1023 }
1027 out_error:
1029 }
1031 /*
1032 * Calculate distance from head to tail (i.e., unused space in the log).
1033 */
1037 xfs_daddr_t head_blk,
1038 xfs_daddr_t tail_blk)
1039 {
1044 }
1046 /*
1047 * Verify the log tail. This is particularly important when torn or incomplete
1048 * writes have been detected near the front of the log and the head has been
1049 * walked back accordingly.
1050 *
1051 * We also have to handle the case where the tail was pinned and the head
1052 * blocked behind the tail right before a crash. If the tail had been pushed
1053 * immediately prior to the crash and the subsequent checkpoint was only
1054 * partially written, it's possible it overwrote the last referenced tail in the
1055 * log with garbage. This is not a coherency problem because the tail must have
1056 * been pushed before it can be overwritten, but appears as log corruption to
1057 * recovery because we have no way to know the tail was updated if the
1058 * subsequent checkpoint didn't write successfully.
1059 *
1060 * Therefore, CRC check the log from tail to head. If a failure occurs and the
1061 * offending record is within max iclog bufs from the head, walk the tail
1062 * forward and retry until a valid tail is found or corruption is detected out
1063 * of the range of a possible overwrite.
1064 */
1065 STATIC int
1068 xfs_daddr_t head_blk,
1071 {
1074 xfs_daddr_t first_bad;
1077 xfs_daddr_t tmp_tail;
1084 /*
1085 * Make sure the tail points to a record (returns positive count on
1086 * success).
1087 */
1095 /*
1096 * Run a CRC check from the tail to the head. We can't just check
1097 * MAX_ICLOGS records past the tail because the tail may point to stale
1098 * blocks cleared during the search for the head/tail. These blocks are
1099 * overwritten with zero-length records and thus record count is not a
1100 * reliable indicator of the iclog state before a crash.
1101 */
1108 /*
1109 * Is corruption within range of the head? If so, retry from
1110 * the next record. Otherwise return an error.
1111 */
1116 /* skip to the next record; returns positive count on success */
1126 }
1132 out:
1135 }
1137 /*
1138 * Detect and trim torn writes from the head of the log.
1139 *
1140 * Storage without sector atomicity guarantees can result in torn writes in the
1141 * log in the event of a crash. Our only means to detect this scenario is via
1142 * CRC verification. While we can't always be certain that CRC verification
1143 * failure is due to a torn write vs. an unrelated corruption, we do know that
1144 * only a certain number (XLOG_MAX_ICLOGS) of log records can be written out at
1145 * one time. Therefore, CRC verify up to XLOG_MAX_ICLOGS records at the head of
1146 * the log and treat failures in this range as torn writes as a matter of
1147 * policy. In the event of CRC failure, the head is walked back to the last good
1148 * record in the log and the tail is updated from that record and verified.
1149 */
1150 STATIC int
1159 {
1162 xfs_daddr_t first_bad;
1163 xfs_daddr_t tmp_rhead_blk;
1168 /*
1169 * Check the head of the log for torn writes. Search backwards from the
1170 * head until we hit the tail or the maximum number of log record I/Os
1171 * that could have been in flight at one time. Use a temporary buffer so
1172 * we don't trash the rhead/bp pointers from the caller.
1173 */
1184 /*
1185 * Now run a CRC verification pass over the records starting at the
1186 * block found above to the current head. If a CRC failure occurs, the
1187 * log block of the first bad record is saved in first_bad.
1188 */
1192 /*
1193 * We've hit a potential torn write. Reset the error and warn
1194 * about it.
1195 */
1201 /*
1202 * Get the header block and buffer pointer for the last good
1203 * record before the bad record.
1204 *
1205 * Note that xlog_find_tail() clears the blocks at the new head
1206 * (i.e., the records with invalid CRC) if the cycle number
1207 * matches the the current cycle.
1208 */
1216 /*
1217 * Reset the head block to the starting block of the first bad
1218 * log record and set the tail block based on the last good
1219 * record.
1220 *
1221 * Bail out if the updated head/tail match as this indicates
1222 * possible corruption outside of the acceptable
1223 * (XLOG_MAX_ICLOGS) range. This is a job for xfs_repair...
1224 */
1230 }
1231 }
1237 }
1239 /*
1240 * Check whether the head of the log points to an unmount record. In other
1241 * words, determine whether the log is clean. If so, update the in-core state
1242 * appropriately.
1243 */
1244 static int
1250 xfs_daddr_t rhead_blk,
1253 {
1255 xfs_daddr_t umount_data_blk;
1256 xfs_daddr_t after_umount_blk;
1263 /*
1264 * Look for unmount record. If we find it, then we know there was a
1265 * clean unmount. Since 'i' could be the last block in the physical
1266 * log, we convert to a log block before comparing to the head_blk.
1267 *
1268 * Save the current tail lsn to use to pass to xlog_clear_stale_blocks()
1269 * below. We won't want to clear the unmount record if there is one, so
1270 * we pass the lsn of the unmount record rather than the block after it.
1271 */
1280 hblks++;
1283 }
1286 }
1299 /*
1300 * Set tail and last sync so that newly written log
1301 * records will point recovery to after the current
1302 * unmount record.
1303 */
1311 }
1312 }
1315 }
1317 static void
1320 xfs_daddr_t head_blk,
1322 xfs_daddr_t rhead_blk,
1324 {
1325 /*
1326 * Reset log values according to the state of the log when we
1327 * crashed. In the case where head_blk == 0, we bump curr_cycle
1328 * one because the next write starts a new cycle rather than
1329 * continuing the cycle of the last good log record. At this
1330 * point we have guaranteed that all partial log records have been
1331 * accounted for. Therefore, we know that the last good log record
1332 * written was complete and ended exactly on the end boundary
1333 * of the physical log.
1334 */
1346 }
1348 /*
1349 * Find the sync block number or the tail of the log.
1350 *
1351 * This will be the block number of the last record to have its
1352 * associated buffers synced to disk. Every log record header has
1353 * a sync lsn embedded in it. LSNs hold block numbers, so it is easy
1354 * to get a sync block number. The only concern is to figure out which
1355 * log record header to believe.
1356 *
1357 * The following algorithm uses the log record header with the largest
1358 * lsn. The entire log record does not need to be valid. We only care
1359 * that the header is valid.
1360 *
1361 * We could speed up search by using current head_blk buffer, but it is not
1362 * available.
1363 */
1364 STATIC int
1369 {
1374 xfs_daddr_t rhead_blk;
1375 xfs_lsn_t tail_lsn;
1379 /*
1380 * Find previous log record
1381 */
1396 /* leave all other log inited values alone */
1398 }
1399 }
1401 /*
1402 * Search backwards through the log looking for the log record header
1403 * block. This wraps all the way back around to the head so something is
1404 * seriously wrong if we can't find it.
1405 */
1413 }
1416 /*
1417 * Set the log state based on the current head record.
1418 */
1422 /*
1423 * Look for an unmount record at the head of the log. This sets the log
1424 * state to determine whether recovery is necessary.
1425 */
1431 /*
1432 * Verify the log head if the log is not clean (e.g., we have anything
1433 * but an unmount record at the head). This uses CRC verification to
1434 * detect and trim torn writes. If discovered, CRC failures are
1435 * considered torn writes and the log head is trimmed accordingly.
1436 *
1437 * Note that we can only run CRC verification when the log is dirty
1438 * because there's no guarantee that the log data behind an unmount
1439 * record is compatible with the current architecture.
1440 */
1449 /* update in-core state again if the head changed */
1452 wrapped);
1459 }
1460 }
1462 /*
1463 * Note that the unmount was clean. If the unmount was not clean, we
1464 * need to know this to rebuild the superblock counters from the perag
1465 * headers if we have a filesystem using non-persistent counters.
1466 */
1470 /*
1471 * Make sure that there are no blocks in front of the head
1472 * with the same cycle number as the head. This can happen
1473 * because we allow multiple outstanding log writes concurrently,
1474 * and the later writes might make it out before earlier ones.
1475 *
1476 * We use the lsn from before modifying it so that we'll never
1477 * overwrite the unmount record after a clean unmount.
1478 *
1479 * Do this only if we are going to recover the filesystem
1480 *
1481 * NOTE: This used to say "if (!readonly)"
1482 * However on Linux, we can & do recover a read-only filesystem.
1483 * We only skip recovery if NORECOVERY is specified on mount,
1484 * in which case we would not be here.
1485 *
1486 * But... if the -device- itself is readonly, just skip this.
1487 * We can't recover this device anyway, so it won't matter.
1488 */
1492 done:
1498 }
1500 /*
1501 * Is the log zeroed at all?
1502 *
1503 * The last binary search should be changed to perform an X block read
1504 * once X becomes small enough. You can then search linearly through
1505 * the X blocks. This will cut down on the number of reads we need to do.
1506 *
1507 * If the log is partially zeroed, this routine will pass back the blkno
1508 * of the first block with cycle number 0. It won't have a complete LR
1509 * preceding it.
1510 *
1511 * Return:
1512 * 0 => the log is completely written to
1513 * 1 => use *blk_no as the first block of the log
1514 * <0 => error has occurred
1515 */
1516 STATIC int
1520 {
1525 xfs_daddr_t num_scan_bblks;
1530 /* check totally zeroed log */
1543 }
1545 /* check partially zeroed log */
1555 /*
1556 * If the cycle of the last block is zero, the cycle of
1557 * the first block must be 1. If it's not, maybe we're
1558 * not looking at a log... Bail out.
1559 */
1564 }
1566 /* we have a partially zeroed log */
1571 /*
1572 * Validate the answer. Because there is no way to guarantee that
1573 * the entire log is made up of log records which are the same size,
1574 * we scan over the defined maximum blocks. At this point, the maximum
1575 * is not chosen to mean anything special. XXXmiken
1576 */
1584 /*
1585 * We search for any instances of cycle number 0 that occur before
1586 * our current estimate of the head. What we're trying to detect is
1587 * 1 ... | 0 | 1 | 0...
1588 * ^ binary search ends here
1589 */
1596 /*
1597 * Potentially backup over partial log record write. We don't need
1598 * to search the end of the log because we know it is zero.
1599 */
1607 bp_err:
1612 }
1614 /*
1615 * These are simple subroutines used by xlog_clear_stale_blocks() below
1616 * to initialize a buffer full of empty log record headers and write
1617 * them into the log.
1618 */
1619 STATIC void
1627 {
1639 }
1641 STATIC int
1649 {
1659 /*
1660 * Greedily allocate a buffer big enough to handle the full
1661 * range of basic blocks to be written. If that fails, try
1662 * a smaller size. We need to be able to write at least a
1663 * log sector, or we're out of luck.
1664 */
1672 }
1674 /* We may need to do a read at the start to fill in part of
1675 * the buffer in the starting sector not covered by the first
1676 * write below.
1677 */
1685 }
1693 /* We may need to do a read at the end to fill in part of
1694 * the buffer in the final sector not covered by the write.
1695 * If this is the same sector as the above read, skip it.
1696 */
1705 }
1712 }
1718 }
1720 out_put_bp:
1723 }
1725 /*
1726 * This routine is called to blow away any incomplete log writes out
1727 * in front of the log head. We do this so that we won't become confused
1728 * if we come up, write only a little bit more, and then crash again.
1729 * If we leave the partial log records out there, this situation could
1730 * cause us to think those partial writes are valid blocks since they
1731 * have the current cycle number. We get rid of them by overwriting them
1732 * with empty log records with the old cycle number rather than the
1733 * current one.
1734 *
1735 * The tail lsn is passed in rather than taken from
1736 * the log so that we will not write over the unmount record after a
1737 * clean unmount in a 512 block log. Doing so would leave the log without
1738 * any valid log records in it until a new one was written. If we crashed
1739 * during that time we would not be able to recover.
1740 */
1741 STATIC int
1744 xfs_lsn_t tail_lsn)
1745 {
1757 /*
1758 * Figure out the distance between the new head of the log
1759 * and the tail. We want to write over any blocks beyond the
1760 * head that we may have written just before the crash, but
1761 * we don't want to overwrite the tail of the log.
1762 */
1764 /*
1765 * The tail is behind the head in the physical log,
1766 * so the distance from the head to the tail is the
1767 * distance from the head to the end of the log plus
1768 * the distance from the beginning of the log to the
1769 * tail.
1770 */
1775 }
1778 /*
1779 * The head is behind the tail in the physical log,
1780 * so the distance from the head to the tail is just
1781 * the tail block minus the head block.
1782 */
1787 }
1789 }
1791 /*
1792 * If the head is right up against the tail, we can't clear
1793 * anything.
1794 */
1798 }
1801 /*
1802 * Take the smaller of the maximum amount of outstanding I/O
1803 * we could have and the distance to the tail to clear out.
1804 * We take the smaller so that we don't overwrite the tail and
1805 * we don't waste all day writing from the head to the tail
1806 * for no reason.
1807 */
1811 /*
1812 * We can stomp all the blocks we need to without
1813 * wrapping around the end of the log. Just do it
1814 * in a single write. Use the cycle number of the
1815 * current cycle minus one so that the log will look like:
1816 * n ... | n - 1 ...
1817 */
1820 tail_block);
1824 /*
1825 * We need to wrap around the end of the physical log in
1826 * order to clear all the blocks. Do it in two separate
1827 * I/Os. The first write should be from the head to the
1828 * end of the physical log, and it should use the current
1829 * cycle number minus one just like above.
1830 */
1834 tail_block);
1839 /*
1840 * Now write the blocks at the start of the physical log.
1841 * This writes the remainder of the blocks we want to clear.
1842 * It uses the current cycle number since we're now on the
1843 * same cycle as the head so that we get:
1844 * n ... n ... | n - 1 ...
1845 * ^^^^^ blocks we're writing
1846 */
1852 }
1855 }
1857 /******************************************************************************
1858 *
1859 * Log recover routines
1860 *
1861 ******************************************************************************
1862 */
1864 /*
1865 * Sort the log items in the transaction.
1866 *
1867 * The ordering constraints are defined by the inode allocation and unlink
1868 * behaviour. The rules are:
1869 *
1870 * 1. Every item is only logged once in a given transaction. Hence it
1871 * represents the last logged state of the item. Hence ordering is
1872 * dependent on the order in which operations need to be performed so
1873 * required initial conditions are always met.
1874 *
1875 * 2. Cancelled buffers are recorded in pass 1 in a separate table and
1876 * there's nothing to replay from them so we can simply cull them
1877 * from the transaction. However, we can't do that until after we've
1878 * replayed all the other items because they may be dependent on the
1879 * cancelled buffer and replaying the cancelled buffer can remove it
1880 * form the cancelled buffer table. Hence they have tobe done last.
1881 *
1882 * 3. Inode allocation buffers must be replayed before inode items that
1883 * read the buffer and replay changes into it. For filesystems using the
1884 * ICREATE transactions, this means XFS_LI_ICREATE objects need to get
1885 * treated the same as inode allocation buffers as they create and
1886 * initialise the buffers directly.
1887 *
1888 * 4. Inode unlink buffers must be replayed after inode items are replayed.
1889 * This ensures that inodes are completely flushed to the inode buffer
1890 * in a "free" state before we remove the unlinked inode list pointer.
1891 *
1892 * Hence the ordering needs to be inode allocation buffers first, inode items
1893 * second, inode unlink buffers third and cancelled buffers last.
1894 *
1895 * But there's a problem with that - we can't tell an inode allocation buffer
1896 * apart from a regular buffer, so we can't separate them. We can, however,
1897 * tell an inode unlink buffer from the others, and so we can separate them out
1898 * from all the other buffers and move them to last.
1899 *
1900 * Hence, 4 lists, in order from head to tail:
1901 * - buffer_list for all buffers except cancelled/inode unlink buffers
1902 * - item_list for all non-buffer items
1903 * - inode_buffer_list for inode unlink buffers
1904 * - cancel_list for the cancelled buffers
1905 *
1906 * Note that we add objects to the tail of the lists so that first-to-last
1907 * ordering is preserved within the lists. Adding objects to the head of the
1908 * list means when we traverse from the head we walk them in last-to-first
1909 * order. For cancelled buffers and inode unlink buffers this doesn't matter,
1910 * but for all other items there may be specific ordering that we need to
1911 * preserve.
1912 */
1913 STATIC int
1918 {
1941 }
1945 }
1966 __func__);
1968 /*
1969 * return the remaining items back to the transaction
1970 * item list so they can be freed in caller.
1971 */
1976 }
1977 }
1978 out:
1989 }
1991 /*
1992 * Build up the table of buf cancel records so that we don't replay
1993 * cancelled data in the second pass. For buffer records that are
1994 * not cancel records, there is nothing to do here so we just return.
1995 *
1996 * If we get a cancel record which is already in the table, this indicates
1997 * that the buffer was cancelled multiple times. In order to ensure
1998 * that during pass 2 we keep the record in the table until we reach its
1999 * last occurrence in the log, we keep a reference count in the cancel
2000 * record in the table to tell us how many times we expect to see this
2001 * record during the second pass.
2002 */
2003 STATIC int
2007 {
2012 /*
2013 * If this isn't a cancel buffer item, then just return.
2014 */
2018 }
2020 /*
2021 * Insert an xfs_buf_cancel record into the hash table of them.
2022 * If there is already an identical record, bump its reference count.
2023 */
2031 }
2032 }
2042 }
2044 /*
2045 * Check to see whether the buffer being recovered has a corresponding
2046 * entry in the buffer cancel record table. If it is, return the cancel
2047 * buffer structure to the caller.
2048 */
2052 xfs_daddr_t blkno,
2053 uint len,
2055 {
2060 /* empty table means no cancelled buffers in the log */
2063 }
2069 }
2071 /*
2072 * We didn't find a corresponding entry in the table, so return 0 so
2073 * that the buffer is NOT cancelled.
2074 */
2077 }
2079 /*
2080 * If the buffer is being cancelled then return 1 so that it will be cancelled,
2081 * otherwise return 0. If the buffer is actually a buffer cancel item
2082 * (XFS_BLF_CANCEL is set), then decrement the refcount on the entry in the
2083 * table and remove it from the table if this is the last reference.
2084 *
2085 * We remove the cancel record from the table when we encounter its last
2086 * occurrence in the log so that if the same buffer is re-used again after its
2087 * last cancellation we actually replay the changes made at that point.
2088 */
2089 STATIC int
2092 xfs_daddr_t blkno,
2093 uint len,
2095 {
2102 /*
2103 * We've go a match, so return 1 so that the recovery of this buffer
2104 * is cancelled. If this buffer is actually a buffer cancel log
2105 * item, then decrement the refcount on the one in the table and
2106 * remove it if this is the last reference.
2107 */
2112 }
2113 }
2115 }
2117 /*
2118 * Perform recovery for a buffer full of inodes. In these buffers, the only
2119 * data which should be recovered is that which corresponds to the
2120 * di_next_unlinked pointers in the on disk inode structures. The rest of the
2121 * data for the inodes is always logged through the inodes themselves rather
2122 * than the inode buffer and is recovered in xlog_recover_inode_pass2().
2123 *
2124 * The only time when buffers full of inodes are fully recovered is when the
2125 * buffer is full of newly allocated inodes. In this case the buffer will
2126 * not be marked as an inode buffer and so will be sent to
2127 * xlog_recover_do_reg_buffer() below during recovery.
2128 */
2129 STATIC int
2135 {
2149 /*
2150 * Post recovery validation only works properly on CRC enabled
2151 * filesystems.
2152 */
2163 /*
2164 * The next di_next_unlinked field is beyond
2165 * the current logged region. Find the next
2166 * logged region that contains or is beyond
2167 * the current di_next_unlinked field.
2168 */
2173 /*
2174 * If there are no more logged regions in the
2175 * buffer, then we're done.
2176 */
2185 item_index++;
2186 }
2188 /*
2189 * If the current logged region starts after the current
2190 * di_next_unlinked field, then move on to the next
2191 * di_next_unlinked field.
2192 */
2201 /*
2202 * The current logged region contains a copy of the
2203 * current di_next_unlinked field. Extract its value
2204 * and copy it to the buffer copy.
2205 */
2210 "Bad inode buffer log record (ptr = 0x%p, bp = 0x%p). "
2216 }
2221 /*
2222 * If necessary, recalculate the CRC in the on-disk inode. We
2223 * have to leave the inode in a consistent state for whoever
2224 * reads it next....
2225 */
2229 }
2232 }
2234 /*
2235 * V5 filesystems know the age of the buffer on disk being recovered. We can
2236 * have newer objects on disk than we are replaying, and so for these cases we
2237 * don't want to replay the current change as that will make the buffer contents
2238 * temporarily invalid on disk.
2239 *
2240 * The magic number might not match the buffer type we are going to recover
2241 * (e.g. reallocated blocks), so we ignore the xfs_buf_log_format flags. Hence
2242 * extract the LSN of the existing object in the buffer based on it's current
2243 * magic number. If we don't recognise the magic number in the buffer, then
2244 * return a LSN of -1 so that the caller knows it was an unrecognised block and
2245 * so can recover the buffer.
2246 *
2247 * Note: we cannot rely solely on magic number matches to determine that the
2248 * buffer has a valid LSN - we also need to verify that it belongs to this
2249 * filesystem, so we need to extract the object's LSN and compare it to that
2250 * which we read from the superblock. If the UUIDs don't match, then we've got a
2251 * stale metadata block from an old filesystem instance that we need to recover
2252 * over the top of.
2253 */
2254 static xfs_lsn_t
2258 {
2266 /* v4 filesystems always recover immediately */
2285 }
2293 }
2317 /*
2318 * Remote attr blocks are written synchronously, rather than
2319 * being logged. That means they do not contain a valid LSN
2320 * (i.e. transactionally ordered) in them, and hence any time we
2321 * see a buffer to replay over the top of a remote attribute
2322 * block we should simply do so.
2323 */
2326 /*
2327 * superblock uuids are magic. We may or may not have a
2328 * sb_meta_uuid on disk, but it will be set in the in-core
2329 * superblock. We set the uuid pointer for verification
2330 * according to the superblock feature mask to ensure we check
2331 * the relevant UUID in the superblock.
2332 */
2336 else
2341 }
2347 }
2359 }
2365 }
2367 /*
2368 * We do individual object checks on dquot and inode buffers as they
2369 * have their own individual LSN records. Also, we could have a stale
2370 * buffer here, so we have to at least recognise these buffer types.
2371 *
2372 * A notd complexity here is inode unlinked list processing - it logs
2373 * the inode directly in the buffer, but we don't know which inodes have
2374 * been modified, and there is no global buffer LSN. Hence we need to
2375 * recover all inode buffer types immediately. This problem will be
2376 * fixed by logical logging of the unlinked list modifications.
2377 */
2385 }
2387 /* unknown buffer contents, recover immediately */
2389 recover_immediately:
2392 }
2394 /*
2395 * Validate the recovered buffer is of the correct type and attach the
2396 * appropriate buffer operations to them for writeback. Magic numbers are in a
2397 * few places:
2398 * the first 16 bits of the buffer (inode buffer, dquot buffer),
2399 * the first 32 bits of the buffer (most blocks),
2400 * inside a struct xfs_da_blkinfo at the start of the buffer.
2401 */
2402 static void
2407 xfs_lsn_t current_lsn)
2408 {
2415 /*
2416 * We can only do post recovery validation on items on CRC enabled
2417 * fielsystems as we need to know when the buffer was written to be able
2418 * to determine if we should have replayed the item. If we replay old
2419 * metadata over a newer buffer, then it will enter a temporarily
2420 * inconsistent state resulting in verification failures. Hence for now
2421 * just avoid the verification stage for non-crc filesystems
2422 */
2457 }
2463 }
2470 }
2477 }
2483 #ifdef CONFIG_XFS_QUOTA
2487 }
2489 #else
2493 #endif
2499 }
2506 }
2514 }
2522 }
2530 }
2538 }
2546 }
2554 }
2562 }
2569 }
2576 }
2579 #ifdef CONFIG_XFS_RT
2582 /* no magic numbers for verification of RT buffers */
2590 }
2592 /*
2593 * Nothing else to do in the case of a NULL current LSN as this means
2594 * the buffer is more recent than the change in the log and will be
2595 * skipped.
2596 */
2603 }
2605 /*
2606 * We must update the metadata LSN of the buffer as it is written out to
2607 * ensure that older transactions never replay over this one and corrupt
2608 * the buffer. This can occur if log recovery is interrupted at some
2609 * point after the current transaction completes, at which point a
2610 * subsequent mount starts recovery from the beginning.
2611 *
2612 * Write verifiers update the metadata LSN from log items attached to
2613 * the buffer. Therefore, initialize a bli purely to carry the LSN to
2614 * the verifier. We'll clean it up in our ->iodone() callback.
2615 */
2624 }
2625 }
2627 /*
2628 * Perform a 'normal' buffer recovery. Each logged region of the
2629 * buffer should be copied over the corresponding region in the
2630 * given buffer. The bitmap in the buf log format structure indicates
2631 * where to place the logged data.
2632 */
2633 STATIC void
2639 xfs_lsn_t current_lsn)
2640 {
2663 /*
2664 * The dirty regions logged in the buffer, even though
2665 * contiguous, may span multiple chunks. This is because the
2666 * dirty region may span a physical page boundary in a buffer
2667 * and hence be split into two separate vectors for writing into
2668 * the log. Hence we need to trim nbits back to the length of
2669 * the current region being copied out of the log.
2670 */
2674 /*
2675 * Do a sanity check if this is a dquot buffer. Just checking
2676 * the first dquot in the buffer should do. XXXThis is
2677 * probably a good thing to do for other buf types also.
2678 */
2686 }
2692 }
2698 }
2704 next:
2705 i++;
2707 }
2709 /* Shouldn't be any more regions */
2713 }
2715 /*
2716 * Perform a dquot buffer recovery.
2717 * Simple algorithm: if we have found a QUOTAOFF log item of the same type
2718 * (ie. USR or GRP), then just toss this buffer away; don't recover it.
2719 * Else, treat it as a regular buffer and do recovery.
2720 *
2721 * Return false if the buffer was tossed and true if we recovered the buffer to
2722 * indicate to the caller if the buffer needs writing.
2723 */
2724 STATIC bool
2731 {
2732 uint type;
2736 /*
2737 * Filesystems are required to send in quota flags at mount time.
2738 */
2749 /*
2750 * This type of quotas was turned off, so ignore this buffer
2751 */
2757 }
2759 /*
2760 * This routine replays a modification made to a buffer at runtime.
2761 * There are actually two types of buffer, regular and inode, which
2762 * are handled differently. Inode buffers are handled differently
2763 * in that we only recover a specific set of data from them, namely
2764 * the inode di_next_unlinked fields. This is because all other inode
2765 * data is actually logged via inode records and any data we replay
2766 * here which overlaps that may be stale.
2767 *
2768 * When meta-data buffers are freed at run time we log a buffer item
2769 * with the XFS_BLF_CANCEL bit set to indicate that previous copies
2770 * of the buffer in the log should not be replayed at recovery time.
2771 * This is so that if the blocks covered by the buffer are reused for
2772 * file data before we crash we don't end up replaying old, freed
2773 * meta-data into a user's file.
2774 *
2775 * To handle the cancellation of buffer log items, we make two passes
2776 * over the log during recovery. During the first we build a table of
2777 * those buffers which have been cancelled, and during the second we
2778 * only replay those buffers which do not have corresponding cancel
2779 * records in the table. See xlog_recover_buffer_pass[1,2] above
2780 * for more details on the implementation of the table of cancel records.
2781 */
2782 STATIC int
2787 xfs_lsn_t current_lsn)
2788 {
2793 uint buf_flags;
2794 xfs_lsn_t lsn;
2796 /*
2797 * In this pass we only want to recover all the buffers which have
2798 * not been cancelled and are not cancellation buffers themselves.
2799 */
2804 }
2820 }
2822 /*
2823 * Recover the buffer only if we get an LSN from it and it's less than
2824 * the lsn of the transaction we are replaying.
2825 *
2826 * Note that we have to be extremely careful of readahead here.
2827 * Readahead does not attach verfiers to the buffers so if we don't
2828 * actually do any replay after readahead because of the LSN we found
2829 * in the buffer if more recent than that current transaction then we
2830 * need to attach the verifier directly. Failure to do so can lead to
2831 * future recovery actions (e.g. EFI and unlinked list recovery) can
2832 * operate on the buffers and they won't get the verifier attached. This
2833 * can lead to blocks on disk having the correct content but a stale
2834 * CRC.
2835 *
2836 * It is safe to assume these clean buffers are currently up to date.
2837 * If the buffer is dirtied by a later transaction being replayed, then
2838 * the verifier will be reset to match whatever recover turns that
2839 * buffer into.
2840 */
2846 }
2861 }
2863 /*
2864 * Perform delayed write on the buffer. Asynchronous writes will be
2865 * slower when taking into account all the buffers to be flushed.
2866 *
2867 * Also make sure that only inode buffers with good sizes stay in
2868 * the buffer cache. The kernel moves inodes in buffers of 1 block
2869 * or mp->m_inode_cluster_size bytes, whichever is bigger. The inode
2870 * buffers in the log can be a different size if the log was generated
2871 * by an older kernel using unclustered inode buffers or a newer kernel
2872 * running with a different inode cluster size. Regardless, if the
2873 * the inode buffer size isn't MAX(blocksize, mp->m_inode_cluster_size)
2874 * for *our* value of mp->m_inode_cluster_size, then we need to keep
2875 * the buffer out of the buffer cache so that the buffer won't
2876 * overlap with future reads of those inodes.
2877 */
2888 }
2890 out_release:
2893 }
2895 /*
2896 * Inode fork owner changes
2897 *
2898 * If we have been told that we have to reparent the inode fork, it's because an
2899 * extent swap operation on a CRC enabled filesystem has been done and we are
2900 * replaying it. We need to walk the BMBT of the appropriate fork and change the
2901 * owners of it.
2902 *
2903 * The complexity here is that we don't have an inode context to work with, so
2904 * after we've replayed the inode we need to instantiate one. This is where the
2905 * fun begins.
2906 *
2907 * We are in the middle of log recovery, so we can't run transactions. That
2908 * means we cannot use cache coherent inode instantiation via xfs_iget(), as
2909 * that will result in the corresponding iput() running the inode through
2910 * xfs_inactive(). If we've just replayed an inode core that changes the link
2911 * count to zero (i.e. it's been unlinked), then xfs_inactive() will run
2912 * transactions (bad!).
2913 *
2914 * So, to avoid this, we instantiate an inode directly from the inode core we've
2915 * just recovered. We have the buffer still locked, and all we really need to
2916 * instantiate is the inode core and the forks being modified. We can do this
2917 * manually, then run the inode btree owner change, and then tear down the
2918 * xfs_inode without having to run any transactions at all.
2919 *
2920 * Also, because we don't have a transaction context available here but need to
2921 * gather all the buffers we modify for writeback so we pass the buffer_list
2922 * instead for the operation to use.
2923 */
2925 STATIC int
2931 {
2941 /* instantiate the inode */
2956 }
2964 }
2966 out_free_ip:
2969 }
2971 STATIC int
2976 xfs_lsn_t current_lsn)
2977 {
2987 uint fields;
2989 uint isize;
3000 }
3002 /*
3003 * Inode buffers can be freed, look out for it,
3004 * and do not replay the inode.
3005 */
3011 }
3019 }
3024 }
3028 /*
3029 * Make sure the place we're flushing out to really looks
3030 * like an inode!
3031 */
3040 }
3050 }
3052 /*
3053 * If the inode has an LSN in it, recover the inode only if it's less
3054 * than the lsn of the transaction we are replaying. Note: we still
3055 * need to replay an owner change even though the inode is more recent
3056 * than the transaction as there is no guarantee that all the btree
3057 * blocks are more recent than this transaction, too.
3058 */
3066 }
3067 }
3069 /*
3070 * di_flushiter is only valid for v1/2 inodes. All changes for v3 inodes
3071 * are transactional and if ordering is necessary we can determine that
3072 * more accurately by the LSN field in the V3 inode core. Don't trust
3073 * the inode versions we might be changing them here - use the
3074 * superblock flag to determine whether we need to look at di_flushiter
3075 * to skip replay when the on disk inode is newer than the log one
3076 */
3079 /*
3080 * Deal with the wrap case, DI_MAX_FLUSH is less
3081 * than smaller numbers
3082 */
3085 /* do nothing */
3090 }
3091 }
3093 /* Take the opportunity to reset the flush iteration count */
3102 "%s: Bad regular inode log record, rec ptr 0x%p, "
3107 }
3115 "%s: Bad dir inode log record, rec ptr 0x%p, "
3120 }
3121 }
3126 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
3133 }
3138 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
3143 }
3153 }
3155 /* recover the log dinode inode into the on disk inode */
3158 /* the rest is in on-disk format */
3163 }
3175 }
3199 /*
3200 * There are no data fork flags set.
3201 */
3204 }
3206 /*
3207 * If we logged any attribute data, recover it. There may or
3208 * may not have been any other non-core data logged in this
3209 * transaction.
3210 */
3216 }
3241 }
3242 }
3244 out_owner_change:
3247 buffer_list);
3248 /* re-generate the checksum. */
3255 out_release:
3257 error:
3261 }
3263 /*
3264 * Recover QUOTAOFF records. We simply make a note of it in the xlog
3265 * structure, so that we know not to do any dquot item or dquot buffer recovery,
3266 * of that type.
3267 */
3268 STATIC int
3272 {
3276 /*
3277 * The logitem format's flag tells us if this was user quotaoff,
3278 * group/project quotaoff or both.
3279 */
3288 }
3290 /*
3291 * Recover a dquot record
3292 */
3293 STATIC int
3298 xfs_lsn_t current_lsn)
3299 {
3305 uint type;
3308 /*
3309 * Filesystems are required to send in quota flags at mount time.
3310 */
3318 }
3323 }
3325 /*
3326 * This type of quotas was turned off, so ignore this record.
3327 */
3333 /*
3334 * At this point we know that quota was _not_ turned off.
3335 * Since the mount flags are not indicating to us otherwise, this
3336 * must mean that quota is on, and the dquot needs to be replayed.
3337 * Remember that we may not have fully recovered the superblock yet,
3338 * so we can't do the usual trick of looking at the SB quota bits.
3339 *
3340 * The other possibility, of course, is that the quota subsystem was
3341 * removed since the last mount - ENOSYS.
3342 */
3351 /*
3352 * At this point we are assuming that the dquots have been allocated
3353 * and hence the buffer has valid dquots stamped in it. It should,
3354 * therefore, pass verifier validation. If the dquot is bad, then the
3355 * we'll return an error here, so we don't need to specifically check
3356 * the dquot in the buffer after the verifier has run.
3357 */
3367 /*
3368 * If the dquot has an LSN in it, recover the dquot only if it's less
3369 * than the lsn of the transaction we are replaying.
3370 */
3377 }
3378 }
3383 XFS_DQUOT_CRC_OFF);
3384 }
3391 out_release:
3394 }
3396 /*
3397 * This routine is called to create an in-core extent free intent
3398 * item from the efi format structure which was logged on disk.
3399 * It allocates an in-core efi, copies the extents from the format
3400 * structure into it, and adds the efi to the AIL with the given
3401 * LSN.
3402 */
3403 STATIC int
3407 xfs_lsn_t lsn)
3408 {
3421 }
3425 /*
3426 * The EFI has two references. One for the EFD and one for EFI to ensure
3427 * it makes it into the AIL. Insert the EFI into the AIL directly and
3428 * drop the EFI reference. Note that xfs_trans_ail_update() drops the
3429 * AIL lock.
3430 */
3434 }
3437 /*
3438 * This routine is called when an EFD format structure is found in a committed
3439 * transaction in the log. Its purpose is to cancel the corresponding EFI if it
3440 * was still in the log. To do this it searches the AIL for the EFI with an id
3441 * equal to that in the EFD format structure. If we find it we drop the EFD
3442 * reference, which removes the EFI from the AIL and frees it.
3443 */
3444 STATIC int
3448 {
3463 /*
3464 * Search for the EFI with the id in the EFD format structure in the
3465 * AIL.
3466 */
3473 /*
3474 * Drop the EFD reference to the EFI. This
3475 * removes the EFI from the AIL and frees it.
3476 */
3481 }
3482 }
3484 }
3490 }
3492 /*
3493 * This routine is called to create an in-core extent rmap update
3494 * item from the rui format structure which was logged on disk.
3495 * It allocates an in-core rui, copies the extents from the format
3496 * structure into it, and adds the rui to the AIL with the given
3497 * LSN.
3498 */
3499 STATIC int
3503 xfs_lsn_t lsn)
3504 {
3517 }
3521 /*
3522 * The RUI has two references. One for the RUD and one for RUI to ensure
3523 * it makes it into the AIL. Insert the RUI into the AIL directly and
3524 * drop the RUI reference. Note that xfs_trans_ail_update() drops the
3525 * AIL lock.
3526 */
3530 }
3533 /*
3534 * This routine is called when an RUD format structure is found in a committed
3535 * transaction in the log. Its purpose is to cancel the corresponding RUI if it
3536 * was still in the log. To do this it searches the AIL for the RUI with an id
3537 * equal to that in the RUD format structure. If we find it we drop the RUD
3538 * reference, which removes the RUI from the AIL and frees it.
3539 */
3540 STATIC int
3544 {
3556 /*
3557 * Search for the RUI with the id in the RUD format structure in the
3558 * AIL.
3559 */
3566 /*
3567 * Drop the RUD reference to the RUI. This
3568 * removes the RUI from the AIL and frees it.
3569 */
3574 }
3575 }
3577 }
3583 }
3585 /*
3586 * Copy an CUI format buffer from the given buf, and into the destination
3587 * CUI format structure. The CUI/CUD items were designed not to need any
3588 * special alignment handling.
3589 */
3590 static int
3594 {
3596 uint len;
3604 }
3606 }
3608 /*
3609 * This routine is called to create an in-core extent refcount update
3610 * item from the cui format structure which was logged on disk.
3611 * It allocates an in-core cui, copies the extents from the format
3612 * structure into it, and adds the cui to the AIL with the given
3613 * LSN.
3614 */
3615 STATIC int
3619 xfs_lsn_t lsn)
3620 {
3633 }
3637 /*
3638 * The CUI has two references. One for the CUD and one for CUI to ensure
3639 * it makes it into the AIL. Insert the CUI into the AIL directly and
3640 * drop the CUI reference. Note that xfs_trans_ail_update() drops the
3641 * AIL lock.
3642 */
3646 }
3649 /*
3650 * This routine is called when an CUD format structure is found in a committed
3651 * transaction in the log. Its purpose is to cancel the corresponding CUI if it
3652 * was still in the log. To do this it searches the AIL for the CUI with an id
3653 * equal to that in the CUD format structure. If we find it we drop the CUD
3654 * reference, which removes the CUI from the AIL and frees it.
3655 */
3656 STATIC int
3660 {
3673 /*
3674 * Search for the CUI with the id in the CUD format structure in the
3675 * AIL.
3676 */
3683 /*
3684 * Drop the CUD reference to the CUI. This
3685 * removes the CUI from the AIL and frees it.
3686 */
3691 }
3692 }
3694 }
3700 }
3702 /*
3703 * Copy an BUI format buffer from the given buf, and into the destination
3704 * BUI format structure. The BUI/BUD items were designed not to need any
3705 * special alignment handling.
3706 */
3707 static int
3711 {
3713 uint len;
3721 }
3723 }
3725 /*
3726 * This routine is called to create an in-core extent bmap update
3727 * item from the bui format structure which was logged on disk.
3728 * It allocates an in-core bui, copies the extents from the format
3729 * structure into it, and adds the bui to the AIL with the given
3730 * LSN.
3731 */
3732 STATIC int
3736 xfs_lsn_t lsn)
3737 {
3752 }
3756 /*
3757 * The RUI has two references. One for the RUD and one for RUI to ensure
3758 * it makes it into the AIL. Insert the RUI into the AIL directly and
3759 * drop the RUI reference. Note that xfs_trans_ail_update() drops the
3760 * AIL lock.
3761 */
3765 }
3768 /*
3769 * This routine is called when an BUD format structure is found in a committed
3770 * transaction in the log. Its purpose is to cancel the corresponding BUI if it
3771 * was still in the log. To do this it searches the AIL for the BUI with an id
3772 * equal to that in the BUD format structure. If we find it we drop the BUD
3773 * reference, which removes the BUI from the AIL and frees it.
3774 */
3775 STATIC int
3779 {
3792 /*
3793 * Search for the BUI with the id in the BUD format structure in the
3794 * AIL.
3795 */
3802 /*
3803 * Drop the BUD reference to the BUI. This
3804 * removes the BUI from the AIL and frees it.
3805 */
3810 }
3811 }
3813 }
3819 }
3821 /*
3822 * This routine is called when an inode create format structure is found in a
3823 * committed transaction in the log. It's purpose is to initialise the inodes
3824 * being allocated on disk. This requires us to get inode cluster buffers that
3825 * match the range to be initialised, stamped with inode templates and written
3826 * by delayed write so that subsequent modifications will hit the cached buffer
3827 * and only need writing out at the end of recovery.
3828 */
3829 STATIC int
3834 {
3837 xfs_agnumber_t agno;
3838 xfs_agblock_t agbno;
3841 xfs_agblock_t length;
3852 }
3857 }
3863 }
3868 }
3873 }
3878 }
3883 }
3885 /*
3886 * The inode chunk is either full or sparse and we only support
3887 * m_ialloc_min_blks sized sparse allocations at this time.
3888 */
3894 }
3896 /* verify inode count is consistent with extent length */
3900 __FUNCTION__);
3902 }
3904 /*
3905 * The icreate transaction can cover multiple cluster buffers and these
3906 * buffers could have been freed and reused. Check the individual
3907 * buffers for cancellation so we don't overwrite anything written after
3908 * a cancellation.
3909 */
3914 xfs_daddr_t daddr;
3919 cancel_count++;
3920 }
3922 /*
3923 * We currently only use icreate for a single allocation at a time. This
3924 * means we should expect either all or none of the buffers to be
3925 * cancelled. Be conservative and skip replay if at least one buffer is
3926 * cancelled, but warn the user that something is awry if the buffers
3927 * are not consistent.
3928 *
3929 * XXX: This must be refined to only skip cancelled clusters once we use
3930 * icreate for multiple chunk allocations.
3931 */
3939 }
3944 }
3946 STATIC void
3950 {
3957 }
3961 }
3963 STATIC void
3967 {
3981 }
3988 }
3990 STATIC void
3994 {
3998 uint type;
4026 }
4028 STATIC void
4032 {
4054 }
4055 }
4057 STATIC int
4062 {
4081 /* nothing to do in pass 1 */
4088 }
4089 }
4091 STATIC int
4097 {
4129 /* nothing to do in pass2 */
4136 }
4137 }
4139 STATIC int
4145 {
4154 }
4157 }
4159 /*
4160 * Perform the transaction.
4161 *
4162 * If the transaction modifies a buffer or inode, do it now. Otherwise,
4163 * EFIs and EFDs get queued up by adding entries into the AIL for them.
4164 */
4165 STATIC int
4171 {
4179 #define XLOG_RECOVER_COMMIT_QUEUE_MAX 100
4195 items_queued++;
4201 }
4206 }
4210 }
4212 out:
4218 }
4224 }
4226 STATIC void
4229 {
4235 }
4237 STATIC int
4243 {
4248 /*
4249 * If the transaction is empty, the header was split across this and the
4250 * previous record. Copy the rest of the header.
4251 */
4257 }
4264 }
4266 /* take the tail entry */
4278 }
4280 /*
4281 * The next region to add is the start of a new region. It could be
4282 * a whole region or it could be the first part of a new region. Because
4283 * of this, the assumption here is that the type and size fields of all
4284 * format structures fit into the first 32 bits of the structure.
4285 *
4286 * This works because all regions must be 32 bit aligned. Therefore, we
4287 * either have both fields or we have neither field. In the case we have
4288 * neither field, the data part of the region is zero length. We only have
4289 * a log_op_header and can throw away the header since a new one will appear
4290 * later. If we have at least 4 bytes, then we can determine how many regions
4291 * will appear in the current log item.
4292 */
4293 STATIC int
4299 {
4307 /* we need to catch log corruptions here */
4310 __func__);
4313 }
4319 }
4321 /*
4322 * The transaction header can be arbitrarily split across op
4323 * records. If we don't have the whole thing here, copy what we
4324 * do have and handle the rest in the next record.
4325 */
4330 }
4336 /* take the tail entry */
4340 /* tail item is in use, get a new one */
4344 }
4355 }
4360 KM_SLEEP);
4361 }
4363 /* Description region is ri_buf[0] */
4369 }
4371 /*
4372 * Free up any resources allocated by the transaction
4373 *
4374 * Remember that EFIs, EFDs, and IUNLINKs are handled later.
4375 */
4376 STATIC void
4379 {
4386 /* Free the regions in the item. */
4390 /* Free the item itself */
4393 }
4394 /* Free the transaction recover structure */
4396 }
4398 /*
4399 * On error or completion, trans is freed.
4400 */
4401 STATIC int
4410 {
4414 /* mask off ophdr transaction container flags */
4419 /*
4420 * Callees must not free the trans structure. We'll decide if we need to
4421 * free it or not based on the operation being done and it's result.
4422 */
4424 /* expected flag values */
4434 buffer_list);
4435 /* success or fail, we are now done with this transaction. */
4439 /* unexpected flag values */
4441 /* just skip trans */
4451 }
4455 }
4457 /*
4458 * Lookup the transaction recovery structure associated with the ID in the
4459 * current ophdr. If the transaction doesn't exist and the start flag is set in
4460 * the ophdr, then allocate a new transaction for future ID matches to find.
4461 * Either way, return what we found during the lookup - an existing transaction
4462 * or nothing.
4463 */
4469 {
4471 xlog_tid_t tid;
4479 }
4481 /*
4482 * skip over non-start transaction headers - we could be
4483 * processing slack space before the next transaction starts
4484 */
4490 /*
4491 * This is a new transaction so allocate a new recovery container to
4492 * hold the recovery ops that will follow.
4493 */
4501 /*
4502 * Nothing more to do for this ophdr. Items to be added to this new
4503 * transaction will be in subsequent ophdr containers.
4504 */
4506 }
4508 STATIC int
4518 {
4523 /* Do we understand who wrote this op? */
4530 }
4532 /*
4533 * Check the ophdr contains all the data it is supposed to contain.
4534 */
4540 }
4544 /* nothing to do, so skip over this ophdr */
4546 }
4548 /*
4549 * The recovered buffer queue is drained only once we know that all
4550 * recovery items for the current LSN have been processed. This is
4551 * required because:
4552 *
4553 * - Buffer write submission updates the metadata LSN of the buffer.
4554 * - Log recovery skips items with a metadata LSN >= the current LSN of
4555 * the recovery item.
4556 * - Separate recovery items against the same metadata buffer can share
4557 * a current LSN. I.e., consider that the LSN of a recovery item is
4558 * defined as the starting LSN of the first record in which its
4559 * transaction appears, that a record can hold multiple transactions,
4560 * and/or that a transaction can span multiple records.
4561 *
4562 * In other words, we are allowed to submit a buffer from log recovery
4563 * once per current LSN. Otherwise, we may incorrectly skip recovery
4564 * items and cause corruption.
4565 *
4566 * We don't know up front whether buffers are updated multiple times per
4567 * LSN. Therefore, track the current LSN of each commit log record as it
4568 * is processed and drain the queue when it changes. Use commit records
4569 * because they are ordered correctly by the logging code.
4570 */
4577 }
4581 }
4583 /*
4584 * There are two valid states of the r_state field. 0 indicates that the
4585 * transaction structure is in a normal state. We have either seen the
4586 * start of the transaction or the last operation we added was not a partial
4587 * operation. If the last operation we added to the transaction was a
4588 * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
4589 *
4590 * NOTE: skip LRs with 0 data length.
4591 */
4592 STATIC int
4600 {
4609 /* check the log format matches our own - else we can't recover */
4620 /* errors will abort recovery */
4627 num_logops--;
4628 }
4630 }
4632 /* Recover the EFI if necessary. */
4633 STATIC int
4638 {
4642 /*
4643 * Skip EFIs that we've already processed.
4644 */
4654 }
4656 /* Release the EFI since we're cancelling everything. */
4657 STATIC void
4662 {
4670 }
4672 /* Recover the RUI if necessary. */
4673 STATIC int
4678 {
4682 /*
4683 * Skip RUIs that we've already processed.
4684 */
4694 }
4696 /* Release the RUI since we're cancelling everything. */
4697 STATIC void
4702 {
4710 }
4712 /* Recover the CUI if necessary. */
4713 STATIC int
4718 {
4722 /*
4723 * Skip CUIs that we've already processed.
4724 */
4734 }
4736 /* Release the CUI since we're cancelling everything. */
4737 STATIC void
4742 {
4750 }
4752 /* Recover the BUI if necessary. */
4753 STATIC int
4758 {
4762 /*
4763 * Skip BUIs that we've already processed.
4764 */
4774 }
4776 /* Release the BUI since we're cancelling everything. */
4777 STATIC void
4782 {
4790 }
4792 /* Is this log item a deferred action intent? */
4794 {
4803 }
4804 }
4806 /*
4807 * When this is called, all of the log intent items which did not have
4808 * corresponding log done items should be in the AIL. What we do now
4809 * is update the data structures associated with each one.
4810 *
4811 * Since we process the log intent items in normal transactions, they
4812 * will be removed at some point after the commit. This prevents us
4813 * from just walking down the list processing each one. We'll use a
4814 * flag in the intent item to skip those that we've already processed
4815 * and use the AIL iteration mechanism's generation count to try to
4816 * speed this up at least a bit.
4817 *
4818 * When we start, we know that the intents are the only things in the
4819 * AIL. As we process them, however, other items are added to the
4820 * AIL.
4821 */
4822 STATIC int
4825 {
4830 #if defined(DEBUG) || defined(XFS_WARN)
4831 xfs_lsn_t last_lsn;
4832 #endif
4837 #if defined(DEBUG) || defined(XFS_WARN)
4839 #endif
4841 /*
4842 * We're done when we see something other than an intent.
4843 * There should be no intents left in the AIL now.
4844 */
4846 #ifdef DEBUG
4849 #endif
4851 }
4853 /*
4854 * We should never see a redo item with a LSN higher than
4855 * the last transaction we found in the log at the start
4856 * of recovery.
4857 */
4873 }
4877 }
4878 out:
4882 }
4884 /*
4885 * A cancel occurs when the mount has failed and we're bailing out.
4886 * Release all pending log intent items so they don't pin the AIL.
4887 */
4888 STATIC int
4891 {
4901 /*
4902 * We're done when we see something other than an intent.
4903 * There should be no intents left in the AIL now.
4904 */
4906 #ifdef DEBUG
4909 #endif
4911 }
4926 }
4929 }
4934 }
4936 /*
4937 * This routine performs a transaction to null out a bad inode pointer
4938 * in an agi unlinked inode hash bucket.
4939 */
4940 STATIC void
4943 xfs_agnumber_t agno,
4945 {
4972 out_abort:
4974 out_error:
4977 }
4979 STATIC xfs_agino_t
4982 xfs_agnumber_t agno,
4983 xfs_agino_t agino,
4985 {
4989 xfs_ino_t ino;
4997 /*
4998 * Get the on disk inode to find the next inode in the bucket.
4999 */
5008 /* setup for the next pass */
5012 /*
5013 * Prevent any DMAPI event from being sent when the reference on
5014 * the inode is dropped.
5015 */
5021 fail_iput:
5023 fail:
5024 /*
5025 * We can't read in the inode this bucket points to, or this inode
5026 * is messed up. Just ditch this bucket of inodes. We will lose
5027 * some inodes and space, but at least we won't hang.
5028 *
5029 * Call xlog_recover_clear_agi_bucket() to perform a transaction to
5030 * clear the inode pointer in the bucket.
5031 */
5034 }
5036 /*
5037 * xlog_iunlink_recover
5038 *
5039 * This is called during recovery to process any inodes which
5040 * we unlinked but not freed when the system crashed. These
5041 * inodes will be on the lists in the AGI blocks. What we do
5042 * here is scan all the AGIs and fully truncate and free any
5043 * inodes found on the lists. Each inode is removed from the
5044 * lists when it has been fully truncated and is freed. The
5045 * freeing of the inode and its removal from the list must be
5046 * atomic.
5047 */
5048 STATIC void
5051 {
5053 xfs_agnumber_t agno;
5056 xfs_agino_t agino;
5059 uint mp_dmevmask;
5063 /*
5064 * Prevent any DMAPI event from being sent while in this function.
5065 */
5070 /*
5071 * Find the agi for this ag.
5072 */
5075 /*
5076 * AGI is b0rked. Don't process it.
5077 *
5078 * We should probably mark the filesystem as corrupt
5079 * after we've recovered all the ag's we can....
5080 */
5082 }
5083 /*
5084 * Unlock the buffer so that it can be acquired in the normal
5085 * course of the transaction to truncate and free each inode.
5086 * Because we are not racing with anyone else here for the AGI
5087 * buffer, we don't even need to hold it locked to read the
5088 * initial unlinked bucket entries out of the buffer. We keep
5089 * buffer reference though, so that it stays pinned in memory
5090 * while we need the buffer.
5091 */
5100 }
5101 }
5103 }
5106 }
5108 STATIC int
5113 {
5120 }
5129 }
5130 }
5133 }
5135 /*
5136 * CRC check, unpack and process a log record.
5137 */
5138 STATIC int
5146 {
5149 __le32 crc;
5154 /*
5155 * Nothing else to do if this is a CRC verification pass. Just return
5156 * if this a record with a non-zero crc. Unfortunately, mkfs always
5157 * sets old_crc to 0 so we must consider this valid even on v5 supers.
5158 * Otherwise, return EFSBADCRC on failure so the callers up the stack
5159 * know precisely what failed.
5160 */
5165 }
5167 /*
5168 * We're in the normal recovery path. Issue a warning if and only if the
5169 * CRC in the header is non-zero. This is an advisory warning and the
5170 * zero CRC check prevents warnings from being emitted when upgrading
5171 * the kernel from one that does not add CRCs by default.
5172 */
5180 }
5182 /*
5183 * If the filesystem is CRC enabled, this mismatch becomes a
5184 * fatal log corruption failure.
5185 */
5188 }
5195 buffer_list);
5196 }
5198 STATIC int
5202 xfs_daddr_t blkno)
5203 {
5210 }
5217 }
5219 /* LR body must have data or it wouldn't have been written */
5225 }
5230 }
5232 }
5234 /*
5235 * Read the log from tail to head and process the log records found.
5236 * Handle the two cases where the tail and head are in the same cycle
5237 * and where the active portion of the log wraps around the end of
5238 * the physical log separately. The pass parameter is passed through
5239 * to the routines called to process the data and is not looked at
5240 * here.
5241 */
5242 STATIC int
5245 xfs_daddr_t head_blk,
5246 xfs_daddr_t tail_blk,
5249 {
5252 xfs_daddr_t rhead_blk;
5269 /*
5270 * Read the header of the tail block and get the iclog buffer size from
5271 * h_size. Use this to tell how many sectors make up the log header.
5272 */
5274 /*
5275 * When using variable length iclogs, read first sector of
5276 * iclog header and extract the header size from it. Get a
5277 * new hbp that is the correct size.
5278 */
5292 /*
5293 * xfsprogs has a bug where record length is based on lsunit but
5294 * h_size (iclog size) is hardcoded to 32k. Now that we
5295 * unconditionally CRC verify the unmount record, this means the
5296 * log buffer can be too small for the record and cause an
5297 * overrun.
5298 *
5299 * Detect this condition here. Use lsunit for the buffer size as
5300 * long as this looks like the mkfs case. Otherwise, return an
5301 * error to avoid a buffer overrun.
5302 */
5314 }
5320 hblks++;
5325 }
5331 }
5339 }
5343 /*
5344 * Perform recovery around the end of the physical log.
5345 * When the head is not on the same cycle number as the tail,
5346 * we can't do a sequential recovery.
5347 */
5349 /*
5350 * Check for header wrapping around physical end-of-log
5351 */
5356 /* Read header in one read */
5362 /* This LR is split across physical log end */
5364 /* some data before physical log end */
5373 }
5375 /*
5376 * Note: this black magic still works with
5377 * large sector sizes (non-512) only because:
5378 * - we increased the buffer size originally
5379 * by 1 sector giving us enough extra space
5380 * for the second read;
5381 * - the log start is guaranteed to be sector
5382 * aligned;
5383 * - we read the log end (LR header start)
5384 * _first_, then the log start (LR header end)
5385 * - order is important.
5386 */
5393 }
5403 /*
5404 * Read the log record data in multiple reads if it
5405 * wraps around the end of the log. Note that if the
5406 * header already wrapped, blk_no could point past the
5407 * end of the log. The record data is contiguous in
5408 * that case.
5409 */
5412 /* mod blk_no in case the header wrapped and
5413 * pushed it beyond the end of the log */
5420 /* This log record is split across the
5421 * physical end of log */
5425 /* some data is before the physical
5426 * end of log */
5429 split_bblks =
5437 }
5439 /*
5440 * Note: this black magic still works with
5441 * large sector sizes (non-512) only because:
5442 * - we increased the buffer size originally
5443 * by 1 sector giving us enough extra space
5444 * for the second read;
5445 * - the log start is guaranteed to be sector
5446 * aligned;
5447 * - we read the log end (LR header start)
5448 * _first_, then the log start (LR header end)
5449 * - order is important.
5450 */
5456 }
5465 }
5470 }
5472 /* read first part of physical log */
5483 /* blocks in data section */
5497 }
5499 bread_err2:
5501 bread_err1:
5504 /*
5505 * Submit buffers that have been added from the last record processed,
5506 * regardless of error status.
5507 */
5514 /*
5515 * Transactions are freed at commit time but transactions without commit
5516 * records on disk are never committed. Free any that may be left in the
5517 * hash table.
5518 */
5525 }
5528 }
5530 /*
5531 * Do the recovery of the log. We actually do this in two phases.
5532 * The two passes are necessary in order to implement the function
5533 * of cancelling a record written into the log. The first pass
5534 * determines those things which have been cancelled, and the
5535 * second pass replays log items normally except for those which
5536 * have been cancelled. The handling of the replay and cancellations
5537 * takes place in the log item type specific routines.
5538 *
5539 * The table of items which have cancel records in the log is allocated
5540 * and freed at this level, since only here do we know when all of
5541 * the log recovery has been completed.
5542 */
5543 STATIC int
5546 xfs_daddr_t head_blk,
5547 xfs_daddr_t tail_blk)
5548 {
5553 /*
5554 * First do a pass to find all of the cancelled buf log items.
5555 * Store them in the buf_cancel_table for use in the second pass.
5556 */
5559 KM_SLEEP);
5569 }
5570 /*
5571 * Then do a second pass to actually recover the items in the log.
5572 * When it is complete free the table of buf cancel items.
5573 */
5576 #ifdef DEBUG
5582 }
5589 }
5591 /*
5592 * Do the actual recovery
5593 */
5594 STATIC int
5597 xfs_daddr_t head_blk,
5598 xfs_daddr_t tail_blk)
5599 {
5607 /*
5608 * First replay the images in the log.
5609 */
5614 /*
5615 * If IO errors happened during recovery, bail out.
5616 */
5619 }
5621 /*
5622 * We now update the tail_lsn since much of the recovery has completed
5623 * and there may be space available to use. If there were no extent
5624 * or iunlinks, we can free up the entire log and set the tail_lsn to
5625 * be the last_sync_lsn. This was set in xlog_find_tail to be the
5626 * lsn of the last known good LR on disk. If there are extent frees
5627 * or iunlinks they will have some entries in the AIL; so we look at
5628 * the AIL to determine how to set the tail_lsn.
5629 */
5632 /*
5633 * Now that we've finished replaying all buffer and inode
5634 * updates, re-read in the superblock and reverify it.
5635 */
5647 }
5650 }
5652 /* Convert superblock from on-disk format */
5657 /* re-initialise in-core superblock and geometry structures */
5663 }
5668 /* Normal transactions can now occur */
5671 }
5673 /*
5674 * Perform recovery and re-initialize some log variables in xlog_find_tail.
5675 *
5676 * Return error or zero.
5677 */
5678 int
5681 {
5685 /* find the tail of the log */
5690 /*
5691 * The superblock was read before the log was available and thus the LSN
5692 * could not be verified. Check the superblock LSN against the current
5693 * LSN now that it's known.
5694 */
5700 /* There used to be a comment here:
5701 *
5702 * disallow recovery on read-only mounts. note -- mount
5703 * checks for ENOSPC and turns it into an intelligent
5704 * error message.
5705 * ...but this is no longer true. Now, unless you specify
5706 * NORECOVERY (in which case this function would never be
5707 * called), we just go ahead and recover. We do this all
5708 * under the vfs layer, so we can get away with it unless
5709 * the device itself is read-only, in which case we fail.
5710 */
5713 }
5715 /*
5716 * Version 5 superblock log feature mask validation. We know the
5717 * log is dirty so check if there are any unknown log features
5718 * in what we need to recover. If there are unknown features
5719 * (e.g. unsupported transactions, then simply reject the
5720 * attempt at recovery before touching anything.
5721 */
5724 XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN)) {
5728 XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
5734 }
5736 /*
5737 * Delay log recovery if the debug hook is set. This is debug
5738 * instrumention to coordinate simulation of I/O failures with
5739 * log recovery.
5740 */
5746 }
5754 }
5756 }
5758 /*
5759 * In the first part of recovery we replay inodes and buffers and build
5760 * up the list of extent free items which need to be processed. Here
5761 * we process the extent free items and clean up the on disk unlinked
5762 * inode lists. This is separated from the first part of recovery so
5763 * that the root and real-time bitmap inodes can be read in from disk in
5764 * between the two stages. This is necessary so that we can free space
5765 * in the real-time portion of the file system.
5766 */
5767 int
5770 {
5771 /*
5772 * Now we're ready to do the transactions needed for the
5773 * rest of recovery. Start with completing all the extent
5774 * free intent records and then process the unlinked inode
5775 * lists. At this point, we essentially run in normal mode
5776 * except that we're still performing recovery actions
5777 * rather than accepting new requests.
5778 */
5785 }
5787 /*
5788 * Sync the log to get all the intents out of the AIL.
5789 * This isn't absolutely necessary, but it helps in
5790 * case the unlink transactions would have problems
5791 * pushing the intents out of the way.
5792 */
5805 }
5807 }
5809 int
5812 {
5819 }
5821 #if defined(DEBUG)
5822 /*
5823 * Read all of the agf and agi counters and check that they
5824 * are consistent with the superblock counters.
5825 */
5826 void
5829 {
5834 xfs_agnumber_t agno;
5855 }
5867 }
5868 }
5869 }