| blob | 9b3d7c76915d9c92948bed063d79bd10a6107a77 |
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 nil, 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 * Check the log tail for torn writes. This is required when torn writes are
1033 * detected at the head and the head had to be walked back to a previous record.
1034 * The tail of the previous record must now be verified to ensure the torn
1035 * writes didn't corrupt the previous tail.
1036 *
1037 * Return an error if CRC verification fails as recovery cannot proceed.
1038 */
1039 STATIC int
1042 xfs_daddr_t head_blk,
1043 xfs_daddr_t tail_blk)
1044 {
1047 xfs_daddr_t first_bad;
1051 xfs_daddr_t tmp_head;
1057 /*
1058 * Seek XLOG_MAX_ICLOGS + 1 records past the current tail record to get
1059 * a temporary head block that points after the last possible
1060 * concurrently written record of the tail.
1061 */
1068 }
1070 /*
1071 * If the call above didn't find XLOG_MAX_ICLOGS + 1 records, we ran
1072 * into the actual log head. tmp_head points to the start of the record
1073 * so update it to the actual head block.
1074 */
1078 /*
1079 * We now have a tail and temporary head block that covers at least
1080 * XLOG_MAX_ICLOGS records from the tail. We need to verify that these
1081 * records were completely written. Run a CRC verification pass from
1082 * tail to head and return the result.
1083 */
1087 out:
1090 }
1092 /*
1093 * Detect and trim torn writes from the head of the log.
1094 *
1095 * Storage without sector atomicity guarantees can result in torn writes in the
1096 * log in the event of a crash. Our only means to detect this scenario is via
1097 * CRC verification. While we can't always be certain that CRC verification
1098 * failure is due to a torn write vs. an unrelated corruption, we do know that
1099 * only a certain number (XLOG_MAX_ICLOGS) of log records can be written out at
1100 * one time. Therefore, CRC verify up to XLOG_MAX_ICLOGS records at the head of
1101 * the log and treat failures in this range as torn writes as a matter of
1102 * policy. In the event of CRC failure, the head is walked back to the last good
1103 * record in the log and the tail is updated from that record and verified.
1104 */
1105 STATIC int
1114 {
1117 xfs_daddr_t first_bad;
1118 xfs_daddr_t tmp_rhead_blk;
1123 /*
1124 * Check the head of the log for torn writes. Search backwards from the
1125 * head until we hit the tail or the maximum number of log record I/Os
1126 * that could have been in flight at one time. Use a temporary buffer so
1127 * we don't trash the rhead/bp pointers from the caller.
1128 */
1139 /*
1140 * Now run a CRC verification pass over the records starting at the
1141 * block found above to the current head. If a CRC failure occurs, the
1142 * log block of the first bad record is saved in first_bad.
1143 */
1147 /*
1148 * We've hit a potential torn write. Reset the error and warn
1149 * about it.
1150 */
1156 /*
1157 * Get the header block and buffer pointer for the last good
1158 * record before the bad record.
1159 *
1160 * Note that xlog_find_tail() clears the blocks at the new head
1161 * (i.e., the records with invalid CRC) if the cycle number
1162 * matches the the current cycle.
1163 */
1171 /*
1172 * Reset the head block to the starting block of the first bad
1173 * log record and set the tail block based on the last good
1174 * record.
1175 *
1176 * Bail out if the updated head/tail match as this indicates
1177 * possible corruption outside of the acceptable
1178 * (XLOG_MAX_ICLOGS) range. This is a job for xfs_repair...
1179 */
1185 }
1187 /*
1188 * Now verify the tail based on the updated head. This is
1189 * required because the torn writes trimmed from the head could
1190 * have been written over the tail of a previous record. Return
1191 * any errors since recovery cannot proceed if the tail is
1192 * corrupt.
1193 *
1194 * XXX: This leaves a gap in truly robust protection from torn
1195 * writes in the log. If the head is behind the tail, the tail
1196 * pushes forward to create some space and then a crash occurs
1197 * causing the writes into the previous record's tail region to
1198 * tear, log recovery isn't able to recover.
1199 *
1200 * How likely is this to occur? If possible, can we do something
1201 * more intelligent here? Is it safe to push the tail forward if
1202 * we can determine that the tail is within the range of the
1203 * torn write (e.g., the kernel can only overwrite the tail if
1204 * it has actually been pushed forward)? Alternatively, could we
1205 * somehow prevent this condition at runtime?
1206 */
1208 }
1211 }
1213 /*
1214 * Check whether the head of the log points to an unmount record. In other
1215 * words, determine whether the log is clean. If so, update the in-core state
1216 * appropriately.
1217 */
1218 static int
1224 xfs_daddr_t rhead_blk,
1227 {
1229 xfs_daddr_t umount_data_blk;
1230 xfs_daddr_t after_umount_blk;
1237 /*
1238 * Look for unmount record. If we find it, then we know there was a
1239 * clean unmount. Since 'i' could be the last block in the physical
1240 * log, we convert to a log block before comparing to the head_blk.
1241 *
1242 * Save the current tail lsn to use to pass to xlog_clear_stale_blocks()
1243 * below. We won't want to clear the unmount record if there is one, so
1244 * we pass the lsn of the unmount record rather than the block after it.
1245 */
1254 hblks++;
1257 }
1260 }
1273 /*
1274 * Set tail and last sync so that newly written log
1275 * records will point recovery to after the current
1276 * unmount record.
1277 */
1285 }
1286 }
1289 }
1291 static void
1294 xfs_daddr_t head_blk,
1296 xfs_daddr_t rhead_blk,
1298 {
1299 /*
1300 * Reset log values according to the state of the log when we
1301 * crashed. In the case where head_blk == 0, we bump curr_cycle
1302 * one because the next write starts a new cycle rather than
1303 * continuing the cycle of the last good log record. At this
1304 * point we have guaranteed that all partial log records have been
1305 * accounted for. Therefore, we know that the last good log record
1306 * written was complete and ended exactly on the end boundary
1307 * of the physical log.
1308 */
1320 }
1322 /*
1323 * Find the sync block number or the tail of the log.
1324 *
1325 * This will be the block number of the last record to have its
1326 * associated buffers synced to disk. Every log record header has
1327 * a sync lsn embedded in it. LSNs hold block numbers, so it is easy
1328 * to get a sync block number. The only concern is to figure out which
1329 * log record header to believe.
1330 *
1331 * The following algorithm uses the log record header with the largest
1332 * lsn. The entire log record does not need to be valid. We only care
1333 * that the header is valid.
1334 *
1335 * We could speed up search by using current head_blk buffer, but it is not
1336 * available.
1337 */
1338 STATIC int
1343 {
1348 xfs_daddr_t rhead_blk;
1349 xfs_lsn_t tail_lsn;
1353 /*
1354 * Find previous log record
1355 */
1370 /* leave all other log inited values alone */
1372 }
1373 }
1375 /*
1376 * Search backwards through the log looking for the log record header
1377 * block. This wraps all the way back around to the head so something is
1378 * seriously wrong if we can't find it.
1379 */
1387 }
1390 /*
1391 * Set the log state based on the current head record.
1392 */
1396 /*
1397 * Look for an unmount record at the head of the log. This sets the log
1398 * state to determine whether recovery is necessary.
1399 */
1405 /*
1406 * Verify the log head if the log is not clean (e.g., we have anything
1407 * but an unmount record at the head). This uses CRC verification to
1408 * detect and trim torn writes. If discovered, CRC failures are
1409 * considered torn writes and the log head is trimmed accordingly.
1410 *
1411 * Note that we can only run CRC verification when the log is dirty
1412 * because there's no guarantee that the log data behind an unmount
1413 * record is compatible with the current architecture.
1414 */
1423 /* update in-core state again if the head changed */
1426 wrapped);
1433 }
1434 }
1436 /*
1437 * Note that the unmount was clean. If the unmount was not clean, we
1438 * need to know this to rebuild the superblock counters from the perag
1439 * headers if we have a filesystem using non-persistent counters.
1440 */
1444 /*
1445 * Make sure that there are no blocks in front of the head
1446 * with the same cycle number as the head. This can happen
1447 * because we allow multiple outstanding log writes concurrently,
1448 * and the later writes might make it out before earlier ones.
1449 *
1450 * We use the lsn from before modifying it so that we'll never
1451 * overwrite the unmount record after a clean unmount.
1452 *
1453 * Do this only if we are going to recover the filesystem
1454 *
1455 * NOTE: This used to say "if (!readonly)"
1456 * However on Linux, we can & do recover a read-only filesystem.
1457 * We only skip recovery if NORECOVERY is specified on mount,
1458 * in which case we would not be here.
1459 *
1460 * But... if the -device- itself is readonly, just skip this.
1461 * We can't recover this device anyway, so it won't matter.
1462 */
1466 done:
1472 }
1474 /*
1475 * Is the log zeroed at all?
1476 *
1477 * The last binary search should be changed to perform an X block read
1478 * once X becomes small enough. You can then search linearly through
1479 * the X blocks. This will cut down on the number of reads we need to do.
1480 *
1481 * If the log is partially zeroed, this routine will pass back the blkno
1482 * of the first block with cycle number 0. It won't have a complete LR
1483 * preceding it.
1484 *
1485 * Return:
1486 * 0 => the log is completely written to
1487 * 1 => use *blk_no as the first block of the log
1488 * <0 => error has occurred
1489 */
1490 STATIC int
1494 {
1499 xfs_daddr_t num_scan_bblks;
1504 /* check totally zeroed log */
1517 }
1519 /* check partially zeroed log */
1529 /*
1530 * If the cycle of the last block is zero, the cycle of
1531 * the first block must be 1. If it's not, maybe we're
1532 * not looking at a log... Bail out.
1533 */
1538 }
1540 /* we have a partially zeroed log */
1545 /*
1546 * Validate the answer. Because there is no way to guarantee that
1547 * the entire log is made up of log records which are the same size,
1548 * we scan over the defined maximum blocks. At this point, the maximum
1549 * is not chosen to mean anything special. XXXmiken
1550 */
1558 /*
1559 * We search for any instances of cycle number 0 that occur before
1560 * our current estimate of the head. What we're trying to detect is
1561 * 1 ... | 0 | 1 | 0...
1562 * ^ binary search ends here
1563 */
1570 /*
1571 * Potentially backup over partial log record write. We don't need
1572 * to search the end of the log because we know it is zero.
1573 */
1581 bp_err:
1586 }
1588 /*
1589 * These are simple subroutines used by xlog_clear_stale_blocks() below
1590 * to initialize a buffer full of empty log record headers and write
1591 * them into the log.
1592 */
1593 STATIC void
1601 {
1613 }
1615 STATIC int
1623 {
1633 /*
1634 * Greedily allocate a buffer big enough to handle the full
1635 * range of basic blocks to be written. If that fails, try
1636 * a smaller size. We need to be able to write at least a
1637 * log sector, or we're out of luck.
1638 */
1646 }
1648 /* We may need to do a read at the start to fill in part of
1649 * the buffer in the starting sector not covered by the first
1650 * write below.
1651 */
1659 }
1667 /* We may need to do a read at the end to fill in part of
1668 * the buffer in the final sector not covered by the write.
1669 * If this is the same sector as the above read, skip it.
1670 */
1679 }
1686 }
1692 }
1694 out_put_bp:
1697 }
1699 /*
1700 * This routine is called to blow away any incomplete log writes out
1701 * in front of the log head. We do this so that we won't become confused
1702 * if we come up, write only a little bit more, and then crash again.
1703 * If we leave the partial log records out there, this situation could
1704 * cause us to think those partial writes are valid blocks since they
1705 * have the current cycle number. We get rid of them by overwriting them
1706 * with empty log records with the old cycle number rather than the
1707 * current one.
1708 *
1709 * The tail lsn is passed in rather than taken from
1710 * the log so that we will not write over the unmount record after a
1711 * clean unmount in a 512 block log. Doing so would leave the log without
1712 * any valid log records in it until a new one was written. If we crashed
1713 * during that time we would not be able to recover.
1714 */
1715 STATIC int
1718 xfs_lsn_t tail_lsn)
1719 {
1731 /*
1732 * Figure out the distance between the new head of the log
1733 * and the tail. We want to write over any blocks beyond the
1734 * head that we may have written just before the crash, but
1735 * we don't want to overwrite the tail of the log.
1736 */
1738 /*
1739 * The tail is behind the head in the physical log,
1740 * so the distance from the head to the tail is the
1741 * distance from the head to the end of the log plus
1742 * the distance from the beginning of the log to the
1743 * tail.
1744 */
1749 }
1752 /*
1753 * The head is behind the tail in the physical log,
1754 * so the distance from the head to the tail is just
1755 * the tail block minus the head block.
1756 */
1761 }
1763 }
1765 /*
1766 * If the head is right up against the tail, we can't clear
1767 * anything.
1768 */
1772 }
1775 /*
1776 * Take the smaller of the maximum amount of outstanding I/O
1777 * we could have and the distance to the tail to clear out.
1778 * We take the smaller so that we don't overwrite the tail and
1779 * we don't waste all day writing from the head to the tail
1780 * for no reason.
1781 */
1785 /*
1786 * We can stomp all the blocks we need to without
1787 * wrapping around the end of the log. Just do it
1788 * in a single write. Use the cycle number of the
1789 * current cycle minus one so that the log will look like:
1790 * n ... | n - 1 ...
1791 */
1794 tail_block);
1798 /*
1799 * We need to wrap around the end of the physical log in
1800 * order to clear all the blocks. Do it in two separate
1801 * I/Os. The first write should be from the head to the
1802 * end of the physical log, and it should use the current
1803 * cycle number minus one just like above.
1804 */
1808 tail_block);
1813 /*
1814 * Now write the blocks at the start of the physical log.
1815 * This writes the remainder of the blocks we want to clear.
1816 * It uses the current cycle number since we're now on the
1817 * same cycle as the head so that we get:
1818 * n ... n ... | n - 1 ...
1819 * ^^^^^ blocks we're writing
1820 */
1826 }
1829 }
1831 /******************************************************************************
1832 *
1833 * Log recover routines
1834 *
1835 ******************************************************************************
1836 */
1838 /*
1839 * Sort the log items in the transaction.
1840 *
1841 * The ordering constraints are defined by the inode allocation and unlink
1842 * behaviour. The rules are:
1843 *
1844 * 1. Every item is only logged once in a given transaction. Hence it
1845 * represents the last logged state of the item. Hence ordering is
1846 * dependent on the order in which operations need to be performed so
1847 * required initial conditions are always met.
1848 *
1849 * 2. Cancelled buffers are recorded in pass 1 in a separate table and
1850 * there's nothing to replay from them so we can simply cull them
1851 * from the transaction. However, we can't do that until after we've
1852 * replayed all the other items because they may be dependent on the
1853 * cancelled buffer and replaying the cancelled buffer can remove it
1854 * form the cancelled buffer table. Hence they have tobe done last.
1855 *
1856 * 3. Inode allocation buffers must be replayed before inode items that
1857 * read the buffer and replay changes into it. For filesystems using the
1858 * ICREATE transactions, this means XFS_LI_ICREATE objects need to get
1859 * treated the same as inode allocation buffers as they create and
1860 * initialise the buffers directly.
1861 *
1862 * 4. Inode unlink buffers must be replayed after inode items are replayed.
1863 * This ensures that inodes are completely flushed to the inode buffer
1864 * in a "free" state before we remove the unlinked inode list pointer.
1865 *
1866 * Hence the ordering needs to be inode allocation buffers first, inode items
1867 * second, inode unlink buffers third and cancelled buffers last.
1868 *
1869 * But there's a problem with that - we can't tell an inode allocation buffer
1870 * apart from a regular buffer, so we can't separate them. We can, however,
1871 * tell an inode unlink buffer from the others, and so we can separate them out
1872 * from all the other buffers and move them to last.
1873 *
1874 * Hence, 4 lists, in order from head to tail:
1875 * - buffer_list for all buffers except cancelled/inode unlink buffers
1876 * - item_list for all non-buffer items
1877 * - inode_buffer_list for inode unlink buffers
1878 * - cancel_list for the cancelled buffers
1879 *
1880 * Note that we add objects to the tail of the lists so that first-to-last
1881 * ordering is preserved within the lists. Adding objects to the head of the
1882 * list means when we traverse from the head we walk them in last-to-first
1883 * order. For cancelled buffers and inode unlink buffers this doesn't matter,
1884 * but for all other items there may be specific ordering that we need to
1885 * preserve.
1886 */
1887 STATIC int
1892 {
1915 }
1919 }
1940 __func__);
1942 /*
1943 * return the remaining items back to the transaction
1944 * item list so they can be freed in caller.
1945 */
1950 }
1951 }
1952 out:
1963 }
1965 /*
1966 * Build up the table of buf cancel records so that we don't replay
1967 * cancelled data in the second pass. For buffer records that are
1968 * not cancel records, there is nothing to do here so we just return.
1969 *
1970 * If we get a cancel record which is already in the table, this indicates
1971 * that the buffer was cancelled multiple times. In order to ensure
1972 * that during pass 2 we keep the record in the table until we reach its
1973 * last occurrence in the log, we keep a reference count in the cancel
1974 * record in the table to tell us how many times we expect to see this
1975 * record during the second pass.
1976 */
1977 STATIC int
1981 {
1986 /*
1987 * If this isn't a cancel buffer item, then just return.
1988 */
1992 }
1994 /*
1995 * Insert an xfs_buf_cancel record into the hash table of them.
1996 * If there is already an identical record, bump its reference count.
1997 */
2005 }
2006 }
2016 }
2018 /*
2019 * Check to see whether the buffer being recovered has a corresponding
2020 * entry in the buffer cancel record table. If it is, return the cancel
2021 * buffer structure to the caller.
2022 */
2026 xfs_daddr_t blkno,
2027 uint len,
2028 ushort flags)
2029 {
2034 /* empty table means no cancelled buffers in the log */
2037 }
2043 }
2045 /*
2046 * We didn't find a corresponding entry in the table, so return 0 so
2047 * that the buffer is NOT cancelled.
2048 */
2051 }
2053 /*
2054 * If the buffer is being cancelled then return 1 so that it will be cancelled,
2055 * otherwise return 0. If the buffer is actually a buffer cancel item
2056 * (XFS_BLF_CANCEL is set), then decrement the refcount on the entry in the
2057 * table and remove it from the table if this is the last reference.
2058 *
2059 * We remove the cancel record from the table when we encounter its last
2060 * occurrence in the log so that if the same buffer is re-used again after its
2061 * last cancellation we actually replay the changes made at that point.
2062 */
2063 STATIC int
2066 xfs_daddr_t blkno,
2067 uint len,
2068 ushort flags)
2069 {
2076 /*
2077 * We've go a match, so return 1 so that the recovery of this buffer
2078 * is cancelled. If this buffer is actually a buffer cancel log
2079 * item, then decrement the refcount on the one in the table and
2080 * remove it if this is the last reference.
2081 */
2086 }
2087 }
2089 }
2091 /*
2092 * Perform recovery for a buffer full of inodes. In these buffers, the only
2093 * data which should be recovered is that which corresponds to the
2094 * di_next_unlinked pointers in the on disk inode structures. The rest of the
2095 * data for the inodes is always logged through the inodes themselves rather
2096 * than the inode buffer and is recovered in xlog_recover_inode_pass2().
2097 *
2098 * The only time when buffers full of inodes are fully recovered is when the
2099 * buffer is full of newly allocated inodes. In this case the buffer will
2100 * not be marked as an inode buffer and so will be sent to
2101 * xlog_recover_do_reg_buffer() below during recovery.
2102 */
2103 STATIC int
2109 {
2123 /*
2124 * Post recovery validation only works properly on CRC enabled
2125 * filesystems.
2126 */
2137 /*
2138 * The next di_next_unlinked field is beyond
2139 * the current logged region. Find the next
2140 * logged region that contains or is beyond
2141 * the current di_next_unlinked field.
2142 */
2147 /*
2148 * If there are no more logged regions in the
2149 * buffer, then we're done.
2150 */
2159 item_index++;
2160 }
2162 /*
2163 * If the current logged region starts after the current
2164 * di_next_unlinked field, then move on to the next
2165 * di_next_unlinked field.
2166 */
2175 /*
2176 * The current logged region contains a copy of the
2177 * current di_next_unlinked field. Extract its value
2178 * and copy it to the buffer copy.
2179 */
2184 "Bad inode buffer log record (ptr = 0x%p, bp = 0x%p). "
2190 }
2195 /*
2196 * If necessary, recalculate the CRC in the on-disk inode. We
2197 * have to leave the inode in a consistent state for whoever
2198 * reads it next....
2199 */
2203 }
2206 }
2208 /*
2209 * V5 filesystems know the age of the buffer on disk being recovered. We can
2210 * have newer objects on disk than we are replaying, and so for these cases we
2211 * don't want to replay the current change as that will make the buffer contents
2212 * temporarily invalid on disk.
2213 *
2214 * The magic number might not match the buffer type we are going to recover
2215 * (e.g. reallocated blocks), so we ignore the xfs_buf_log_format flags. Hence
2216 * extract the LSN of the existing object in the buffer based on it's current
2217 * magic number. If we don't recognise the magic number in the buffer, then
2218 * return a LSN of -1 so that the caller knows it was an unrecognised block and
2219 * so can recover the buffer.
2220 *
2221 * Note: we cannot rely solely on magic number matches to determine that the
2222 * buffer has a valid LSN - we also need to verify that it belongs to this
2223 * filesystem, so we need to extract the object's LSN and compare it to that
2224 * which we read from the superblock. If the UUIDs don't match, then we've got a
2225 * stale metadata block from an old filesystem instance that we need to recover
2226 * over the top of.
2227 */
2228 static xfs_lsn_t
2232 {
2233 __uint32_t magic32;
2234 __uint16_t magic16;
2235 __uint16_t magicda;
2240 /* v4 filesystems always recover immediately */
2259 }
2267 }
2291 /*
2292 * Remote attr blocks are written synchronously, rather than
2293 * being logged. That means they do not contain a valid LSN
2294 * (i.e. transactionally ordered) in them, and hence any time we
2295 * see a buffer to replay over the top of a remote attribute
2296 * block we should simply do so.
2297 */
2300 /*
2301 * superblock uuids are magic. We may or may not have a
2302 * sb_meta_uuid on disk, but it will be set in the in-core
2303 * superblock. We set the uuid pointer for verification
2304 * according to the superblock feature mask to ensure we check
2305 * the relevant UUID in the superblock.
2306 */
2310 else
2315 }
2321 }
2333 }
2339 }
2341 /*
2342 * We do individual object checks on dquot and inode buffers as they
2343 * have their own individual LSN records. Also, we could have a stale
2344 * buffer here, so we have to at least recognise these buffer types.
2345 *
2346 * A notd complexity here is inode unlinked list processing - it logs
2347 * the inode directly in the buffer, but we don't know which inodes have
2348 * been modified, and there is no global buffer LSN. Hence we need to
2349 * recover all inode buffer types immediately. This problem will be
2350 * fixed by logical logging of the unlinked list modifications.
2351 */
2359 }
2361 /* unknown buffer contents, recover immediately */
2363 recover_immediately:
2366 }
2368 /*
2369 * Validate the recovered buffer is of the correct type and attach the
2370 * appropriate buffer operations to them for writeback. Magic numbers are in a
2371 * few places:
2372 * the first 16 bits of the buffer (inode buffer, dquot buffer),
2373 * the first 32 bits of the buffer (most blocks),
2374 * inside a struct xfs_da_blkinfo at the start of the buffer.
2375 */
2376 static void
2381 xfs_lsn_t current_lsn)
2382 {
2384 __uint32_t magic32;
2385 __uint16_t magic16;
2386 __uint16_t magicda;
2389 /*
2390 * We can only do post recovery validation on items on CRC enabled
2391 * fielsystems as we need to know when the buffer was written to be able
2392 * to determine if we should have replayed the item. If we replay old
2393 * metadata over a newer buffer, then it will enter a temporarily
2394 * inconsistent state resulting in verification failures. Hence for now
2395 * just avoid the verification stage for non-crc filesystems
2396 */
2431 }
2437 }
2444 }
2451 }
2457 #ifdef CONFIG_XFS_QUOTA
2461 }
2463 #else
2467 #endif
2473 }
2480 }
2488 }
2496 }
2504 }
2512 }
2520 }
2528 }
2536 }
2543 }
2550 }
2553 #ifdef CONFIG_XFS_RT
2556 /* no magic numbers for verification of RT buffers */
2564 }
2566 /*
2567 * Nothing else to do in the case of a NULL current LSN as this means
2568 * the buffer is more recent than the change in the log and will be
2569 * skipped.
2570 */
2577 }
2579 /*
2580 * We must update the metadata LSN of the buffer as it is written out to
2581 * ensure that older transactions never replay over this one and corrupt
2582 * the buffer. This can occur if log recovery is interrupted at some
2583 * point after the current transaction completes, at which point a
2584 * subsequent mount starts recovery from the beginning.
2585 *
2586 * Write verifiers update the metadata LSN from log items attached to
2587 * the buffer. Therefore, initialize a bli purely to carry the LSN to
2588 * the verifier. We'll clean it up in our ->iodone() callback.
2589 */
2598 }
2599 }
2601 /*
2602 * Perform a 'normal' buffer recovery. Each logged region of the
2603 * buffer should be copied over the corresponding region in the
2604 * given buffer. The bitmap in the buf log format structure indicates
2605 * where to place the logged data.
2606 */
2607 STATIC void
2613 xfs_lsn_t current_lsn)
2614 {
2637 /*
2638 * The dirty regions logged in the buffer, even though
2639 * contiguous, may span multiple chunks. This is because the
2640 * dirty region may span a physical page boundary in a buffer
2641 * and hence be split into two separate vectors for writing into
2642 * the log. Hence we need to trim nbits back to the length of
2643 * the current region being copied out of the log.
2644 */
2648 /*
2649 * Do a sanity check if this is a dquot buffer. Just checking
2650 * the first dquot in the buffer should do. XXXThis is
2651 * probably a good thing to do for other buf types also.
2652 */
2660 }
2666 }
2672 }
2678 next:
2679 i++;
2681 }
2683 /* Shouldn't be any more regions */
2687 }
2689 /*
2690 * Perform a dquot buffer recovery.
2691 * Simple algorithm: if we have found a QUOTAOFF log item of the same type
2692 * (ie. USR or GRP), then just toss this buffer away; don't recover it.
2693 * Else, treat it as a regular buffer and do recovery.
2694 *
2695 * Return false if the buffer was tossed and true if we recovered the buffer to
2696 * indicate to the caller if the buffer needs writing.
2697 */
2698 STATIC bool
2705 {
2706 uint type;
2710 /*
2711 * Filesystems are required to send in quota flags at mount time.
2712 */
2723 /*
2724 * This type of quotas was turned off, so ignore this buffer
2725 */
2731 }
2733 /*
2734 * This routine replays a modification made to a buffer at runtime.
2735 * There are actually two types of buffer, regular and inode, which
2736 * are handled differently. Inode buffers are handled differently
2737 * in that we only recover a specific set of data from them, namely
2738 * the inode di_next_unlinked fields. This is because all other inode
2739 * data is actually logged via inode records and any data we replay
2740 * here which overlaps that may be stale.
2741 *
2742 * When meta-data buffers are freed at run time we log a buffer item
2743 * with the XFS_BLF_CANCEL bit set to indicate that previous copies
2744 * of the buffer in the log should not be replayed at recovery time.
2745 * This is so that if the blocks covered by the buffer are reused for
2746 * file data before we crash we don't end up replaying old, freed
2747 * meta-data into a user's file.
2748 *
2749 * To handle the cancellation of buffer log items, we make two passes
2750 * over the log during recovery. During the first we build a table of
2751 * those buffers which have been cancelled, and during the second we
2752 * only replay those buffers which do not have corresponding cancel
2753 * records in the table. See xlog_recover_buffer_pass[1,2] above
2754 * for more details on the implementation of the table of cancel records.
2755 */
2756 STATIC int
2761 xfs_lsn_t current_lsn)
2762 {
2767 uint buf_flags;
2768 xfs_lsn_t lsn;
2770 /*
2771 * In this pass we only want to recover all the buffers which have
2772 * not been cancelled and are not cancellation buffers themselves.
2773 */
2778 }
2794 }
2796 /*
2797 * Recover the buffer only if we get an LSN from it and it's less than
2798 * the lsn of the transaction we are replaying.
2799 *
2800 * Note that we have to be extremely careful of readahead here.
2801 * Readahead does not attach verfiers to the buffers so if we don't
2802 * actually do any replay after readahead because of the LSN we found
2803 * in the buffer if more recent than that current transaction then we
2804 * need to attach the verifier directly. Failure to do so can lead to
2805 * future recovery actions (e.g. EFI and unlinked list recovery) can
2806 * operate on the buffers and they won't get the verifier attached. This
2807 * can lead to blocks on disk having the correct content but a stale
2808 * CRC.
2809 *
2810 * It is safe to assume these clean buffers are currently up to date.
2811 * If the buffer is dirtied by a later transaction being replayed, then
2812 * the verifier will be reset to match whatever recover turns that
2813 * buffer into.
2814 */
2820 }
2835 }
2837 /*
2838 * Perform delayed write on the buffer. Asynchronous writes will be
2839 * slower when taking into account all the buffers to be flushed.
2840 *
2841 * Also make sure that only inode buffers with good sizes stay in
2842 * the buffer cache. The kernel moves inodes in buffers of 1 block
2843 * or mp->m_inode_cluster_size bytes, whichever is bigger. The inode
2844 * buffers in the log can be a different size if the log was generated
2845 * by an older kernel using unclustered inode buffers or a newer kernel
2846 * running with a different inode cluster size. Regardless, if the
2847 * the inode buffer size isn't MAX(blocksize, mp->m_inode_cluster_size)
2848 * for *our* value of mp->m_inode_cluster_size, then we need to keep
2849 * the buffer out of the buffer cache so that the buffer won't
2850 * overlap with future reads of those inodes.
2851 */
2862 }
2864 out_release:
2867 }
2869 /*
2870 * Inode fork owner changes
2871 *
2872 * If we have been told that we have to reparent the inode fork, it's because an
2873 * extent swap operation on a CRC enabled filesystem has been done and we are
2874 * replaying it. We need to walk the BMBT of the appropriate fork and change the
2875 * owners of it.
2876 *
2877 * The complexity here is that we don't have an inode context to work with, so
2878 * after we've replayed the inode we need to instantiate one. This is where the
2879 * fun begins.
2880 *
2881 * We are in the middle of log recovery, so we can't run transactions. That
2882 * means we cannot use cache coherent inode instantiation via xfs_iget(), as
2883 * that will result in the corresponding iput() running the inode through
2884 * xfs_inactive(). If we've just replayed an inode core that changes the link
2885 * count to zero (i.e. it's been unlinked), then xfs_inactive() will run
2886 * transactions (bad!).
2887 *
2888 * So, to avoid this, we instantiate an inode directly from the inode core we've
2889 * just recovered. We have the buffer still locked, and all we really need to
2890 * instantiate is the inode core and the forks being modified. We can do this
2891 * manually, then run the inode btree owner change, and then tear down the
2892 * xfs_inode without having to run any transactions at all.
2893 *
2894 * Also, because we don't have a transaction context available here but need to
2895 * gather all the buffers we modify for writeback so we pass the buffer_list
2896 * instead for the operation to use.
2897 */
2899 STATIC int
2905 {
2915 /* instantiate the inode */
2930 }
2938 }
2940 out_free_ip:
2943 }
2945 STATIC int
2950 xfs_lsn_t current_lsn)
2951 {
2961 uint fields;
2963 uint isize;
2974 }
2976 /*
2977 * Inode buffers can be freed, look out for it,
2978 * and do not replay the inode.
2979 */
2985 }
2993 }
2998 }
3002 /*
3003 * Make sure the place we're flushing out to really looks
3004 * like an inode!
3005 */
3014 }
3024 }
3026 /*
3027 * If the inode has an LSN in it, recover the inode only if it's less
3028 * than the lsn of the transaction we are replaying. Note: we still
3029 * need to replay an owner change even though the inode is more recent
3030 * than the transaction as there is no guarantee that all the btree
3031 * blocks are more recent than this transaction, too.
3032 */
3040 }
3041 }
3043 /*
3044 * di_flushiter is only valid for v1/2 inodes. All changes for v3 inodes
3045 * are transactional and if ordering is necessary we can determine that
3046 * more accurately by the LSN field in the V3 inode core. Don't trust
3047 * the inode versions we might be changing them here - use the
3048 * superblock flag to determine whether we need to look at di_flushiter
3049 * to skip replay when the on disk inode is newer than the log one
3050 */
3053 /*
3054 * Deal with the wrap case, DI_MAX_FLUSH is less
3055 * than smaller numbers
3056 */
3059 /* do nothing */
3064 }
3065 }
3067 /* Take the opportunity to reset the flush iteration count */
3076 "%s: Bad regular inode log record, rec ptr 0x%p, "
3081 }
3089 "%s: Bad dir inode log record, rec ptr 0x%p, "
3094 }
3095 }
3100 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
3107 }
3112 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
3117 }
3127 }
3129 /* recover the log dinode inode into the on disk inode */
3132 /* the rest is in on-disk format */
3137 }
3149 }
3173 /*
3174 * There are no data fork flags set.
3175 */
3178 }
3180 /*
3181 * If we logged any attribute data, recover it. There may or
3182 * may not have been any other non-core data logged in this
3183 * transaction.
3184 */
3190 }
3215 }
3216 }
3218 out_owner_change:
3221 buffer_list);
3222 /* re-generate the checksum. */
3229 out_release:
3231 error:
3235 }
3237 /*
3238 * Recover QUOTAOFF records. We simply make a note of it in the xlog
3239 * structure, so that we know not to do any dquot item or dquot buffer recovery,
3240 * of that type.
3241 */
3242 STATIC int
3246 {
3250 /*
3251 * The logitem format's flag tells us if this was user quotaoff,
3252 * group/project quotaoff or both.
3253 */
3262 }
3264 /*
3265 * Recover a dquot record
3266 */
3267 STATIC int
3272 xfs_lsn_t current_lsn)
3273 {
3279 uint type;
3282 /*
3283 * Filesystems are required to send in quota flags at mount time.
3284 */
3292 }
3297 }
3299 /*
3300 * This type of quotas was turned off, so ignore this record.
3301 */
3307 /*
3308 * At this point we know that quota was _not_ turned off.
3309 * Since the mount flags are not indicating to us otherwise, this
3310 * must mean that quota is on, and the dquot needs to be replayed.
3311 * Remember that we may not have fully recovered the superblock yet,
3312 * so we can't do the usual trick of looking at the SB quota bits.
3313 *
3314 * The other possibility, of course, is that the quota subsystem was
3315 * removed since the last mount - ENOSYS.
3316 */
3325 /*
3326 * At this point we are assuming that the dquots have been allocated
3327 * and hence the buffer has valid dquots stamped in it. It should,
3328 * therefore, pass verifier validation. If the dquot is bad, then the
3329 * we'll return an error here, so we don't need to specifically check
3330 * the dquot in the buffer after the verifier has run.
3331 */
3341 /*
3342 * If the dquot has an LSN in it, recover the dquot only if it's less
3343 * than the lsn of the transaction we are replaying.
3344 */
3351 }
3352 }
3357 XFS_DQUOT_CRC_OFF);
3358 }
3365 out_release:
3368 }
3370 /*
3371 * This routine is called to create an in-core extent free intent
3372 * item from the efi format structure which was logged on disk.
3373 * It allocates an in-core efi, copies the extents from the format
3374 * structure into it, and adds the efi to the AIL with the given
3375 * LSN.
3376 */
3377 STATIC int
3381 xfs_lsn_t lsn)
3382 {
3395 }
3399 /*
3400 * The EFI has two references. One for the EFD and one for EFI to ensure
3401 * it makes it into the AIL. Insert the EFI into the AIL directly and
3402 * drop the EFI reference. Note that xfs_trans_ail_update() drops the
3403 * AIL lock.
3404 */
3408 }
3411 /*
3412 * This routine is called when an EFD format structure is found in a committed
3413 * transaction in the log. Its purpose is to cancel the corresponding EFI if it
3414 * was still in the log. To do this it searches the AIL for the EFI with an id
3415 * equal to that in the EFD format structure. If we find it we drop the EFD
3416 * reference, which removes the EFI from the AIL and frees it.
3417 */
3418 STATIC int
3422 {
3426 __uint64_t efi_id;
3437 /*
3438 * Search for the EFI with the id in the EFD format structure in the
3439 * AIL.
3440 */
3447 /*
3448 * Drop the EFD reference to the EFI. This
3449 * removes the EFI from the AIL and frees it.
3450 */
3455 }
3456 }
3458 }
3464 }
3466 /*
3467 * This routine is called to create an in-core extent rmap update
3468 * item from the rui format structure which was logged on disk.
3469 * It allocates an in-core rui, copies the extents from the format
3470 * structure into it, and adds the rui to the AIL with the given
3471 * LSN.
3472 */
3473 STATIC int
3477 xfs_lsn_t lsn)
3478 {
3491 }
3495 /*
3496 * The RUI has two references. One for the RUD and one for RUI to ensure
3497 * it makes it into the AIL. Insert the RUI into the AIL directly and
3498 * drop the RUI reference. Note that xfs_trans_ail_update() drops the
3499 * AIL lock.
3500 */
3504 }
3507 /*
3508 * This routine is called when an RUD format structure is found in a committed
3509 * transaction in the log. Its purpose is to cancel the corresponding RUI if it
3510 * was still in the log. To do this it searches the AIL for the RUI with an id
3511 * equal to that in the RUD format structure. If we find it we drop the RUD
3512 * reference, which removes the RUI from the AIL and frees it.
3513 */
3514 STATIC int
3518 {
3522 __uint64_t rui_id;
3530 /*
3531 * Search for the RUI with the id in the RUD format structure in the
3532 * AIL.
3533 */
3540 /*
3541 * Drop the RUD reference to the RUI. This
3542 * removes the RUI from the AIL and frees it.
3543 */
3548 }
3549 }
3551 }
3557 }
3559 /*
3560 * Copy an CUI format buffer from the given buf, and into the destination
3561 * CUI format structure. The CUI/CUD items were designed not to need any
3562 * special alignment handling.
3563 */
3564 static int
3568 {
3570 uint len;
3578 }
3580 }
3582 /*
3583 * This routine is called to create an in-core extent refcount update
3584 * item from the cui format structure which was logged on disk.
3585 * It allocates an in-core cui, copies the extents from the format
3586 * structure into it, and adds the cui to the AIL with the given
3587 * LSN.
3588 */
3589 STATIC int
3593 xfs_lsn_t lsn)
3594 {
3607 }
3611 /*
3612 * The CUI has two references. One for the CUD and one for CUI to ensure
3613 * it makes it into the AIL. Insert the CUI into the AIL directly and
3614 * drop the CUI reference. Note that xfs_trans_ail_update() drops the
3615 * AIL lock.
3616 */
3620 }
3623 /*
3624 * This routine is called when an CUD format structure is found in a committed
3625 * transaction in the log. Its purpose is to cancel the corresponding CUI if it
3626 * was still in the log. To do this it searches the AIL for the CUI with an id
3627 * equal to that in the CUD format structure. If we find it we drop the CUD
3628 * reference, which removes the CUI from the AIL and frees it.
3629 */
3630 STATIC int
3634 {
3638 __uint64_t cui_id;
3647 /*
3648 * Search for the CUI with the id in the CUD format structure in the
3649 * AIL.
3650 */
3657 /*
3658 * Drop the CUD reference to the CUI. This
3659 * removes the CUI from the AIL and frees it.
3660 */
3665 }
3666 }
3668 }
3674 }
3676 /*
3677 * Copy an BUI format buffer from the given buf, and into the destination
3678 * BUI format structure. The BUI/BUD items were designed not to need any
3679 * special alignment handling.
3680 */
3681 static int
3685 {
3687 uint len;
3695 }
3697 }
3699 /*
3700 * This routine is called to create an in-core extent bmap update
3701 * item from the bui format structure which was logged on disk.
3702 * It allocates an in-core bui, copies the extents from the format
3703 * structure into it, and adds the bui to the AIL with the given
3704 * LSN.
3705 */
3706 STATIC int
3710 xfs_lsn_t lsn)
3711 {
3726 }
3730 /*
3731 * The RUI has two references. One for the RUD and one for RUI to ensure
3732 * it makes it into the AIL. Insert the RUI into the AIL directly and
3733 * drop the RUI reference. Note that xfs_trans_ail_update() drops the
3734 * AIL lock.
3735 */
3739 }
3742 /*
3743 * This routine is called when an BUD format structure is found in a committed
3744 * transaction in the log. Its purpose is to cancel the corresponding BUI if it
3745 * was still in the log. To do this it searches the AIL for the BUI with an id
3746 * equal to that in the BUD format structure. If we find it we drop the BUD
3747 * reference, which removes the BUI from the AIL and frees it.
3748 */
3749 STATIC int
3753 {
3757 __uint64_t bui_id;
3766 /*
3767 * Search for the BUI with the id in the BUD format structure in the
3768 * AIL.
3769 */
3776 /*
3777 * Drop the BUD reference to the BUI. This
3778 * removes the BUI from the AIL and frees it.
3779 */
3784 }
3785 }
3787 }
3793 }
3795 /*
3796 * This routine is called when an inode create format structure is found in a
3797 * committed transaction in the log. It's purpose is to initialise the inodes
3798 * being allocated on disk. This requires us to get inode cluster buffers that
3799 * match the range to be intialised, stamped with inode templates and written
3800 * by delayed write so that subsequent modifications will hit the cached buffer
3801 * and only need writing out at the end of recovery.
3802 */
3803 STATIC int
3808 {
3811 xfs_agnumber_t agno;
3812 xfs_agblock_t agbno;
3815 xfs_agblock_t length;
3826 }
3831 }
3837 }
3842 }
3847 }
3852 }
3857 }
3859 /*
3860 * The inode chunk is either full or sparse and we only support
3861 * m_ialloc_min_blks sized sparse allocations at this time.
3862 */
3868 }
3870 /* verify inode count is consistent with extent length */
3874 __FUNCTION__);
3876 }
3878 /*
3879 * The icreate transaction can cover multiple cluster buffers and these
3880 * buffers could have been freed and reused. Check the individual
3881 * buffers for cancellation so we don't overwrite anything written after
3882 * a cancellation.
3883 */
3888 xfs_daddr_t daddr;
3893 cancel_count++;
3894 }
3896 /*
3897 * We currently only use icreate for a single allocation at a time. This
3898 * means we should expect either all or none of the buffers to be
3899 * cancelled. Be conservative and skip replay if at least one buffer is
3900 * cancelled, but warn the user that something is awry if the buffers
3901 * are not consistent.
3902 *
3903 * XXX: This must be refined to only skip cancelled clusters once we use
3904 * icreate for multiple chunk allocations.
3905 */
3913 }
3918 }
3920 STATIC void
3924 {
3931 }
3935 }
3937 STATIC void
3941 {
3955 }
3962 }
3964 STATIC void
3968 {
3972 uint type;
4000 }
4002 STATIC void
4006 {
4028 }
4029 }
4031 STATIC int
4036 {
4055 /* nothing to do in pass 1 */
4062 }
4063 }
4065 STATIC int
4071 {
4103 /* nothing to do in pass2 */
4110 }
4111 }
4113 STATIC int
4119 {
4128 }
4131 }
4133 /*
4134 * Perform the transaction.
4135 *
4136 * If the transaction modifies a buffer or inode, do it now. Otherwise,
4137 * EFIs and EFDs get queued up by adding entries into the AIL for them.
4138 */
4139 STATIC int
4145 {
4153 #define XLOG_RECOVER_COMMIT_QUEUE_MAX 100
4169 items_queued++;
4175 }
4180 }
4184 }
4186 out:
4192 }
4198 }
4200 STATIC void
4203 {
4209 }
4211 STATIC int
4217 {
4222 /*
4223 * If the transaction is empty, the header was split across this and the
4224 * previous record. Copy the rest of the header.
4225 */
4231 }
4238 }
4240 /* take the tail entry */
4252 }
4254 /*
4255 * The next region to add is the start of a new region. It could be
4256 * a whole region or it could be the first part of a new region. Because
4257 * of this, the assumption here is that the type and size fields of all
4258 * format structures fit into the first 32 bits of the structure.
4259 *
4260 * This works because all regions must be 32 bit aligned. Therefore, we
4261 * either have both fields or we have neither field. In the case we have
4262 * neither field, the data part of the region is zero length. We only have
4263 * a log_op_header and can throw away the header since a new one will appear
4264 * later. If we have at least 4 bytes, then we can determine how many regions
4265 * will appear in the current log item.
4266 */
4267 STATIC int
4273 {
4281 /* we need to catch log corruptions here */
4284 __func__);
4287 }
4293 }
4295 /*
4296 * The transaction header can be arbitrarily split across op
4297 * records. If we don't have the whole thing here, copy what we
4298 * do have and handle the rest in the next record.
4299 */
4304 }
4310 /* take the tail entry */
4314 /* tail item is in use, get a new one */
4318 }
4329 }
4334 KM_SLEEP);
4335 }
4337 /* Description region is ri_buf[0] */
4343 }
4345 /*
4346 * Free up any resources allocated by the transaction
4347 *
4348 * Remember that EFIs, EFDs, and IUNLINKs are handled later.
4349 */
4350 STATIC void
4353 {
4358 /* Free the regions in the item. */
4362 /* Free the item itself */
4365 }
4366 /* Free the transaction recover structure */
4368 }
4370 /*
4371 * On error or completion, trans is freed.
4372 */
4373 STATIC int
4382 {
4386 /* mask off ophdr transaction container flags */
4391 /*
4392 * Callees must not free the trans structure. We'll decide if we need to
4393 * free it or not based on the operation being done and it's result.
4394 */
4396 /* expected flag values */
4406 buffer_list);
4407 /* success or fail, we are now done with this transaction. */
4411 /* unexpected flag values */
4413 /* just skip trans */
4423 }
4427 }
4429 /*
4430 * Lookup the transaction recovery structure associated with the ID in the
4431 * current ophdr. If the transaction doesn't exist and the start flag is set in
4432 * the ophdr, then allocate a new transaction for future ID matches to find.
4433 * Either way, return what we found during the lookup - an existing transaction
4434 * or nothing.
4435 */
4441 {
4443 xlog_tid_t tid;
4451 }
4453 /*
4454 * skip over non-start transaction headers - we could be
4455 * processing slack space before the next transaction starts
4456 */
4462 /*
4463 * This is a new transaction so allocate a new recovery container to
4464 * hold the recovery ops that will follow.
4465 */
4473 /*
4474 * Nothing more to do for this ophdr. Items to be added to this new
4475 * transaction will be in subsequent ophdr containers.
4476 */
4478 }
4480 STATIC int
4490 {
4495 /* Do we understand who wrote this op? */
4502 }
4504 /*
4505 * Check the ophdr contains all the data it is supposed to contain.
4506 */
4512 }
4516 /* nothing to do, so skip over this ophdr */
4518 }
4520 /*
4521 * The recovered buffer queue is drained only once we know that all
4522 * recovery items for the current LSN have been processed. This is
4523 * required because:
4524 *
4525 * - Buffer write submission updates the metadata LSN of the buffer.
4526 * - Log recovery skips items with a metadata LSN >= the current LSN of
4527 * the recovery item.
4528 * - Separate recovery items against the same metadata buffer can share
4529 * a current LSN. I.e., consider that the LSN of a recovery item is
4530 * defined as the starting LSN of the first record in which its
4531 * transaction appears, that a record can hold multiple transactions,
4532 * and/or that a transaction can span multiple records.
4533 *
4534 * In other words, we are allowed to submit a buffer from log recovery
4535 * once per current LSN. Otherwise, we may incorrectly skip recovery
4536 * items and cause corruption.
4537 *
4538 * We don't know up front whether buffers are updated multiple times per
4539 * LSN. Therefore, track the current LSN of each commit log record as it
4540 * is processed and drain the queue when it changes. Use commit records
4541 * because they are ordered correctly by the logging code.
4542 */
4549 }
4553 }
4555 /*
4556 * There are two valid states of the r_state field. 0 indicates that the
4557 * transaction structure is in a normal state. We have either seen the
4558 * start of the transaction or the last operation we added was not a partial
4559 * operation. If the last operation we added to the transaction was a
4560 * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
4561 *
4562 * NOTE: skip LRs with 0 data length.
4563 */
4564 STATIC int
4572 {
4581 /* check the log format matches our own - else we can't recover */
4592 /* errors will abort recovery */
4599 num_logops--;
4600 }
4602 }
4604 /* Recover the EFI if necessary. */
4605 STATIC int
4610 {
4614 /*
4615 * Skip EFIs that we've already processed.
4616 */
4626 }
4628 /* Release the EFI since we're cancelling everything. */
4629 STATIC void
4634 {
4642 }
4644 /* Recover the RUI if necessary. */
4645 STATIC int
4650 {
4654 /*
4655 * Skip RUIs that we've already processed.
4656 */
4666 }
4668 /* Release the RUI since we're cancelling everything. */
4669 STATIC void
4674 {
4682 }
4684 /* Recover the CUI if necessary. */
4685 STATIC int
4690 {
4694 /*
4695 * Skip CUIs that we've already processed.
4696 */
4706 }
4708 /* Release the CUI since we're cancelling everything. */
4709 STATIC void
4714 {
4722 }
4724 /* Recover the BUI if necessary. */
4725 STATIC int
4730 {
4734 /*
4735 * Skip BUIs that we've already processed.
4736 */
4746 }
4748 /* Release the BUI since we're cancelling everything. */
4749 STATIC void
4754 {
4762 }
4764 /* Is this log item a deferred action intent? */
4766 {
4775 }
4776 }
4778 /*
4779 * When this is called, all of the log intent items which did not have
4780 * corresponding log done items should be in the AIL. What we do now
4781 * is update the data structures associated with each one.
4782 *
4783 * Since we process the log intent items in normal transactions, they
4784 * will be removed at some point after the commit. This prevents us
4785 * from just walking down the list processing each one. We'll use a
4786 * flag in the intent item to skip those that we've already processed
4787 * and use the AIL iteration mechanism's generation count to try to
4788 * speed this up at least a bit.
4789 *
4790 * When we start, we know that the intents are the only things in the
4791 * AIL. As we process them, however, other items are added to the
4792 * AIL.
4793 */
4794 STATIC int
4797 {
4802 xfs_lsn_t last_lsn;
4809 /*
4810 * We're done when we see something other than an intent.
4811 * There should be no intents left in the AIL now.
4812 */
4814 #ifdef DEBUG
4817 #endif
4819 }
4821 /*
4822 * We should never see a redo item with a LSN higher than
4823 * the last transaction we found in the log at the start
4824 * of recovery.
4825 */
4841 }
4845 }
4846 out:
4850 }
4852 /*
4853 * A cancel occurs when the mount has failed and we're bailing out.
4854 * Release all pending log intent items so they don't pin the AIL.
4855 */
4856 STATIC int
4859 {
4869 /*
4870 * We're done when we see something other than an intent.
4871 * There should be no intents left in the AIL now.
4872 */
4874 #ifdef DEBUG
4877 #endif
4879 }
4894 }
4897 }
4902 }
4904 /*
4905 * This routine performs a transaction to null out a bad inode pointer
4906 * in an agi unlinked inode hash bucket.
4907 */
4908 STATIC void
4911 xfs_agnumber_t agno,
4913 {
4940 out_abort:
4942 out_error:
4945 }
4947 STATIC xfs_agino_t
4950 xfs_agnumber_t agno,
4951 xfs_agino_t agino,
4953 {
4957 xfs_ino_t ino;
4965 /*
4966 * Get the on disk inode to find the next inode in the bucket.
4967 */
4976 /* setup for the next pass */
4980 /*
4981 * Prevent any DMAPI event from being sent when the reference on
4982 * the inode is dropped.
4983 */
4989 fail_iput:
4991 fail:
4992 /*
4993 * We can't read in the inode this bucket points to, or this inode
4994 * is messed up. Just ditch this bucket of inodes. We will lose
4995 * some inodes and space, but at least we won't hang.
4996 *
4997 * Call xlog_recover_clear_agi_bucket() to perform a transaction to
4998 * clear the inode pointer in the bucket.
4999 */
5002 }
5004 /*
5005 * xlog_iunlink_recover
5006 *
5007 * This is called during recovery to process any inodes which
5008 * we unlinked but not freed when the system crashed. These
5009 * inodes will be on the lists in the AGI blocks. What we do
5010 * here is scan all the AGIs and fully truncate and free any
5011 * inodes found on the lists. Each inode is removed from the
5012 * lists when it has been fully truncated and is freed. The
5013 * freeing of the inode and its removal from the list must be
5014 * atomic.
5015 */
5016 STATIC void
5019 {
5021 xfs_agnumber_t agno;
5024 xfs_agino_t agino;
5027 uint mp_dmevmask;
5031 /*
5032 * Prevent any DMAPI event from being sent while in this function.
5033 */
5038 /*
5039 * Find the agi for this ag.
5040 */
5043 /*
5044 * AGI is b0rked. Don't process it.
5045 *
5046 * We should probably mark the filesystem as corrupt
5047 * after we've recovered all the ag's we can....
5048 */
5050 }
5051 /*
5052 * Unlock the buffer so that it can be acquired in the normal
5053 * course of the transaction to truncate and free each inode.
5054 * Because we are not racing with anyone else here for the AGI
5055 * buffer, we don't even need to hold it locked to read the
5056 * initial unlinked bucket entries out of the buffer. We keep
5057 * buffer reference though, so that it stays pinned in memory
5058 * while we need the buffer.
5059 */
5068 }
5069 }
5071 }
5074 }
5076 STATIC int
5081 {
5088 }
5097 }
5098 }
5101 }
5103 /*
5104 * CRC check, unpack and process a log record.
5105 */
5106 STATIC int
5114 {
5116 __le32 crc;
5120 /*
5121 * Nothing else to do if this is a CRC verification pass. Just return
5122 * if this a record with a non-zero crc. Unfortunately, mkfs always
5123 * sets h_crc to 0 so we must consider this valid even on v5 supers.
5124 * Otherwise, return EFSBADCRC on failure so the callers up the stack
5125 * know precisely what failed.
5126 */
5131 }
5133 /*
5134 * We're in the normal recovery path. Issue a warning if and only if the
5135 * CRC in the header is non-zero. This is an advisory warning and the
5136 * zero CRC check prevents warnings from being emitted when upgrading
5137 * the kernel from one that does not add CRCs by default.
5138 */
5146 }
5148 /*
5149 * If the filesystem is CRC enabled, this mismatch becomes a
5150 * fatal log corruption failure.
5151 */
5154 }
5161 buffer_list);
5162 }
5164 STATIC int
5168 xfs_daddr_t blkno)
5169 {
5176 }
5183 }
5185 /* LR body must have data or it wouldn't have been written */
5191 }
5196 }
5198 }
5200 /*
5201 * Read the log from tail to head and process the log records found.
5202 * Handle the two cases where the tail and head are in the same cycle
5203 * and where the active portion of the log wraps around the end of
5204 * the physical log separately. The pass parameter is passed through
5205 * to the routines called to process the data and is not looked at
5206 * here.
5207 */
5208 STATIC int
5211 xfs_daddr_t head_blk,
5212 xfs_daddr_t tail_blk,
5215 {
5217 xfs_daddr_t blk_no;
5218 xfs_daddr_t rhead_blk;
5231 /*
5232 * Read the header of the tail block and get the iclog buffer size from
5233 * h_size. Use this to tell how many sectors make up the log header.
5234 */
5236 /*
5237 * When using variable length iclogs, read first sector of
5238 * iclog header and extract the header size from it. Get a
5239 * new hbp that is the correct size.
5240 */
5254 /*
5255 * xfsprogs has a bug where record length is based on lsunit but
5256 * h_size (iclog size) is hardcoded to 32k. Now that we
5257 * unconditionally CRC verify the unmount record, this means the
5258 * log buffer can be too small for the record and cause an
5259 * overrun.
5260 *
5261 * Detect this condition here. Use lsunit for the buffer size as
5262 * long as this looks like the mkfs case. Otherwise, return an
5263 * error to avoid a buffer overrun.
5264 */
5276 }
5282 hblks++;
5287 }
5293 }
5301 }
5306 /*
5307 * Perform recovery around the end of the physical log.
5308 * When the head is not on the same cycle number as the tail,
5309 * we can't do a sequential recovery.
5310 */
5312 /*
5313 * Check for header wrapping around physical end-of-log
5314 */
5319 /* Read header in one read */
5325 /* This LR is split across physical log end */
5327 /* some data before physical log end */
5336 }
5338 /*
5339 * Note: this black magic still works with
5340 * large sector sizes (non-512) only because:
5341 * - we increased the buffer size originally
5342 * by 1 sector giving us enough extra space
5343 * for the second read;
5344 * - the log start is guaranteed to be sector
5345 * aligned;
5346 * - we read the log end (LR header start)
5347 * _first_, then the log start (LR header end)
5348 * - order is important.
5349 */
5356 }
5366 /* Read in data for log record */
5373 /* This log record is split across the
5374 * physical end of log */
5378 /* some data is before the physical
5379 * end of log */
5382 split_bblks =
5390 }
5392 /*
5393 * Note: this black magic still works with
5394 * large sector sizes (non-512) only because:
5395 * - we increased the buffer size originally
5396 * by 1 sector giving us enough extra space
5397 * for the second read;
5398 * - the log start is guaranteed to be sector
5399 * aligned;
5400 * - we read the log end (LR header start)
5401 * _first_, then the log start (LR header end)
5402 * - order is important.
5403 */
5409 }
5418 }
5423 }
5425 /* read first part of physical log */
5436 /* blocks in data section */
5450 }
5452 bread_err2:
5454 bread_err1:
5457 /*
5458 * Submit buffers that have been added from the last record processed,
5459 * regardless of error status.
5460 */
5468 }
5470 /*
5471 * Do the recovery of the log. We actually do this in two phases.
5472 * The two passes are necessary in order to implement the function
5473 * of cancelling a record written into the log. The first pass
5474 * determines those things which have been cancelled, and the
5475 * second pass replays log items normally except for those which
5476 * have been cancelled. The handling of the replay and cancellations
5477 * takes place in the log item type specific routines.
5478 *
5479 * The table of items which have cancel records in the log is allocated
5480 * and freed at this level, since only here do we know when all of
5481 * the log recovery has been completed.
5482 */
5483 STATIC int
5486 xfs_daddr_t head_blk,
5487 xfs_daddr_t tail_blk)
5488 {
5493 /*
5494 * First do a pass to find all of the cancelled buf log items.
5495 * Store them in the buf_cancel_table for use in the second pass.
5496 */
5499 KM_SLEEP);
5509 }
5510 /*
5511 * Then do a second pass to actually recover the items in the log.
5512 * When it is complete free the table of buf cancel items.
5513 */
5516 #ifdef DEBUG
5522 }
5529 }
5531 /*
5532 * Do the actual recovery
5533 */
5534 STATIC int
5537 xfs_daddr_t head_blk,
5538 xfs_daddr_t tail_blk)
5539 {
5545 /*
5546 * First replay the images in the log.
5547 */
5552 /*
5553 * If IO errors happened during recovery, bail out.
5554 */
5557 }
5559 /*
5560 * We now update the tail_lsn since much of the recovery has completed
5561 * and there may be space available to use. If there were no extent
5562 * or iunlinks, we can free up the entire log and set the tail_lsn to
5563 * be the last_sync_lsn. This was set in xlog_find_tail to be the
5564 * lsn of the last known good LR on disk. If there are extent frees
5565 * or iunlinks they will have some entries in the AIL; so we look at
5566 * the AIL to determine how to set the tail_lsn.
5567 */
5570 /*
5571 * Now that we've finished replaying all buffer and inode
5572 * updates, re-read in the superblock and reverify it.
5573 */
5585 }
5588 }
5590 /* Convert superblock from on-disk format */
5595 /* re-initialise in-core superblock and geometry structures */
5601 }
5606 /* Normal transactions can now occur */
5609 }
5611 /*
5612 * Perform recovery and re-initialize some log variables in xlog_find_tail.
5613 *
5614 * Return error or zero.
5615 */
5616 int
5619 {
5623 /* find the tail of the log */
5628 /*
5629 * The superblock was read before the log was available and thus the LSN
5630 * could not be verified. Check the superblock LSN against the current
5631 * LSN now that it's known.
5632 */
5638 /* There used to be a comment here:
5639 *
5640 * disallow recovery on read-only mounts. note -- mount
5641 * checks for ENOSPC and turns it into an intelligent
5642 * error message.
5643 * ...but this is no longer true. Now, unless you specify
5644 * NORECOVERY (in which case this function would never be
5645 * called), we just go ahead and recover. We do this all
5646 * under the vfs layer, so we can get away with it unless
5647 * the device itself is read-only, in which case we fail.
5648 */
5651 }
5653 /*
5654 * Version 5 superblock log feature mask validation. We know the
5655 * log is dirty so check if there are any unknown log features
5656 * in what we need to recover. If there are unknown features
5657 * (e.g. unsupported transactions, then simply reject the
5658 * attempt at recovery before touching anything.
5659 */
5662 XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN)) {
5666 XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
5672 }
5674 /*
5675 * Delay log recovery if the debug hook is set. This is debug
5676 * instrumention to coordinate simulation of I/O failures with
5677 * log recovery.
5678 */
5684 }
5692 }
5694 }
5696 /*
5697 * In the first part of recovery we replay inodes and buffers and build
5698 * up the list of extent free items which need to be processed. Here
5699 * we process the extent free items and clean up the on disk unlinked
5700 * inode lists. This is separated from the first part of recovery so
5701 * that the root and real-time bitmap inodes can be read in from disk in
5702 * between the two stages. This is necessary so that we can free space
5703 * in the real-time portion of the file system.
5704 */
5705 int
5708 {
5709 /*
5710 * Now we're ready to do the transactions needed for the
5711 * rest of recovery. Start with completing all the extent
5712 * free intent records and then process the unlinked inode
5713 * lists. At this point, we essentially run in normal mode
5714 * except that we're still performing recovery actions
5715 * rather than accepting new requests.
5716 */
5723 }
5725 /*
5726 * Sync the log to get all the intents out of the AIL.
5727 * This isn't absolutely necessary, but it helps in
5728 * case the unlink transactions would have problems
5729 * pushing the intents out of the way.
5730 */
5743 }
5745 }
5747 int
5750 {
5757 }
5759 #if defined(DEBUG)
5760 /*
5761 * Read all of the agf and agi counters and check that they
5762 * are consistent with the superblock counters.
5763 */
5764 void
5767 {
5772 xfs_agnumber_t agno;
5773 __uint64_t freeblks;
5774 __uint64_t itotal;
5775 __uint64_t ifree;
5793 }
5805 }
5806 }
5807 }