recovery.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609
  1. /*
  2. * linux/fs/recovery.c
  3. *
  4. * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
  5. *
  6. * Copyright 1999-2000 Red Hat Software --- All Rights Reserved
  7. *
  8. * This file is part of the Linux kernel and is made available under
  9. * the terms of the GNU General Public License, version 2, or at your
  10. * option, any later version, incorporated herein by reference.
  11. *
  12. * Journal recovery routines for the generic filesystem journaling code;
  13. * part of the ext2fs journaling system.
  14. */
  15. #ifndef __KERNEL__
  16. #include "jfs_user.h"
  17. #else
  18. #include <linux/time.h>
  19. #include <linux/fs.h>
  20. #include <linux/jbd2.h>
  21. #include <linux/errno.h>
  22. #include <linux/slab.h>
  23. #endif
  24. /*
  25. * Maintain information about the progress of the recovery job, so that
  26. * the different passes can carry information between them.
  27. */
  28. struct recovery_info
  29. {
  30. tid_t start_transaction;
  31. tid_t end_transaction;
  32. int nr_replays;
  33. int nr_revokes;
  34. int nr_revoke_hits;
  35. };
  36. enum passtype {PASS_SCAN, PASS_REVOKE, PASS_REPLAY};
  37. static int do_one_pass(journal_t *journal,
  38. struct recovery_info *info, enum passtype pass);
  39. static int scan_revoke_records(journal_t *, struct buffer_head *,
  40. tid_t, struct recovery_info *);
  41. #ifdef __KERNEL__
  42. /* Release readahead buffers after use */
  43. static void journal_brelse_array(struct buffer_head *b[], int n)
  44. {
  45. while (--n >= 0)
  46. brelse (b[n]);
  47. }
  48. /*
  49. * When reading from the journal, we are going through the block device
  50. * layer directly and so there is no readahead being done for us. We
  51. * need to implement any readahead ourselves if we want it to happen at
  52. * all. Recovery is basically one long sequential read, so make sure we
  53. * do the IO in reasonably large chunks.
  54. *
  55. * This is not so critical that we need to be enormously clever about
  56. * the readahead size, though. 128K is a purely arbitrary, good-enough
  57. * fixed value.
  58. */
  59. #define MAXBUF 8
  60. static int do_readahead(journal_t *journal, unsigned int start)
  61. {
  62. int err;
  63. unsigned int max, nbufs, next;
  64. unsigned long long blocknr;
  65. struct buffer_head *bh;
  66. struct buffer_head * bufs[MAXBUF];
  67. /* Do up to 128K of readahead */
  68. max = start + (128 * 1024 / journal->j_blocksize);
  69. if (max > journal->j_maxlen)
  70. max = journal->j_maxlen;
  71. /* Do the readahead itself. We'll submit MAXBUF buffer_heads at
  72. * a time to the block device IO layer. */
  73. nbufs = 0;
  74. for (next = start; next < max; next++) {
  75. err = jbd2_journal_bmap(journal, next, &blocknr);
  76. if (err) {
  77. printk (KERN_ERR "JBD: bad block at offset %u\n",
  78. next);
  79. goto failed;
  80. }
  81. bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
  82. if (!bh) {
  83. err = -ENOMEM;
  84. goto failed;
  85. }
  86. if (!buffer_uptodate(bh) && !buffer_locked(bh)) {
  87. bufs[nbufs++] = bh;
  88. if (nbufs == MAXBUF) {
  89. ll_rw_block(READ, nbufs, bufs);
  90. journal_brelse_array(bufs, nbufs);
  91. nbufs = 0;
  92. }
  93. } else
  94. brelse(bh);
  95. }
  96. if (nbufs)
  97. ll_rw_block(READ, nbufs, bufs);
  98. err = 0;
  99. failed:
  100. if (nbufs)
  101. journal_brelse_array(bufs, nbufs);
  102. return err;
  103. }
  104. #endif /* __KERNEL__ */
  105. /*
  106. * Read a block from the journal
  107. */
  108. static int jread(struct buffer_head **bhp, journal_t *journal,
  109. unsigned int offset)
  110. {
  111. int err;
  112. unsigned long long blocknr;
  113. struct buffer_head *bh;
  114. *bhp = NULL;
  115. if (offset >= journal->j_maxlen) {
  116. printk(KERN_ERR "JBD: corrupted journal superblock\n");
  117. return -EIO;
  118. }
  119. err = jbd2_journal_bmap(journal, offset, &blocknr);
  120. if (err) {
  121. printk (KERN_ERR "JBD: bad block at offset %u\n",
  122. offset);
  123. return err;
  124. }
  125. bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
  126. if (!bh)
  127. return -ENOMEM;
  128. if (!buffer_uptodate(bh)) {
  129. /* If this is a brand new buffer, start readahead.
  130. Otherwise, we assume we are already reading it. */
  131. if (!buffer_req(bh))
  132. do_readahead(journal, offset);
  133. wait_on_buffer(bh);
  134. }
  135. if (!buffer_uptodate(bh)) {
  136. printk (KERN_ERR "JBD: Failed to read block at offset %u\n",
  137. offset);
  138. brelse(bh);
  139. return -EIO;
  140. }
  141. *bhp = bh;
  142. return 0;
  143. }
  144. /*
  145. * Count the number of in-use tags in a journal descriptor block.
  146. */
  147. static int count_tags(journal_t *journal, struct buffer_head *bh)
  148. {
  149. char * tagp;
  150. journal_block_tag_t * tag;
  151. int nr = 0, size = journal->j_blocksize;
  152. int tag_bytes = journal_tag_bytes(journal);
  153. tagp = &bh->b_data[sizeof(journal_header_t)];
  154. while ((tagp - bh->b_data + tag_bytes) <= size) {
  155. tag = (journal_block_tag_t *) tagp;
  156. nr++;
  157. tagp += tag_bytes;
  158. if (!(tag->t_flags & cpu_to_be32(JBD2_FLAG_SAME_UUID)))
  159. tagp += 16;
  160. if (tag->t_flags & cpu_to_be32(JBD2_FLAG_LAST_TAG))
  161. break;
  162. }
  163. return nr;
  164. }
  165. /* Make sure we wrap around the log correctly! */
  166. #define wrap(journal, var) \
  167. do { \
  168. if (var >= (journal)->j_last) \
  169. var -= ((journal)->j_last - (journal)->j_first); \
  170. } while (0)
  171. /**
  172. * jbd2_journal_recover - recovers a on-disk journal
  173. * @journal: the journal to recover
  174. *
  175. * The primary function for recovering the log contents when mounting a
  176. * journaled device.
  177. *
  178. * Recovery is done in three passes. In the first pass, we look for the
  179. * end of the log. In the second, we assemble the list of revoke
  180. * blocks. In the third and final pass, we replay any un-revoked blocks
  181. * in the log.
  182. */
  183. int jbd2_journal_recover(journal_t *journal)
  184. {
  185. int err;
  186. journal_superblock_t * sb;
  187. struct recovery_info info;
  188. memset(&info, 0, sizeof(info));
  189. sb = journal->j_superblock;
  190. /*
  191. * The journal superblock's s_start field (the current log head)
  192. * is always zero if, and only if, the journal was cleanly
  193. * unmounted.
  194. */
  195. if (!sb->s_start) {
  196. jbd_debug(1, "No recovery required, last transaction %d\n",
  197. be32_to_cpu(sb->s_sequence));
  198. journal->j_transaction_sequence = be32_to_cpu(sb->s_sequence) + 1;
  199. return 0;
  200. }
  201. err = do_one_pass(journal, &info, PASS_SCAN);
  202. if (!err)
  203. err = do_one_pass(journal, &info, PASS_REVOKE);
  204. if (!err)
  205. err = do_one_pass(journal, &info, PASS_REPLAY);
  206. jbd_debug(0, "JBD: recovery, exit status %d, "
  207. "recovered transactions %u to %u\n",
  208. err, info.start_transaction, info.end_transaction);
  209. jbd_debug(0, "JBD: Replayed %d and revoked %d/%d blocks\n",
  210. info.nr_replays, info.nr_revoke_hits, info.nr_revokes);
  211. /* Restart the log at the next transaction ID, thus invalidating
  212. * any existing commit records in the log. */
  213. journal->j_transaction_sequence = ++info.end_transaction;
  214. jbd2_journal_clear_revoke(journal);
  215. sync_blockdev(journal->j_fs_dev);
  216. return err;
  217. }
  218. /**
  219. * jbd2_journal_skip_recovery - Start journal and wipe exiting records
  220. * @journal: journal to startup
  221. *
  222. * Locate any valid recovery information from the journal and set up the
  223. * journal structures in memory to ignore it (presumably because the
  224. * caller has evidence that it is out of date).
  225. * This function does'nt appear to be exorted..
  226. *
  227. * We perform one pass over the journal to allow us to tell the user how
  228. * much recovery information is being erased, and to let us initialise
  229. * the journal transaction sequence numbers to the next unused ID.
  230. */
  231. int jbd2_journal_skip_recovery(journal_t *journal)
  232. {
  233. int err;
  234. journal_superblock_t * sb;
  235. struct recovery_info info;
  236. memset (&info, 0, sizeof(info));
  237. sb = journal->j_superblock;
  238. err = do_one_pass(journal, &info, PASS_SCAN);
  239. if (err) {
  240. printk(KERN_ERR "JBD: error %d scanning journal\n", err);
  241. ++journal->j_transaction_sequence;
  242. } else {
  243. #ifdef CONFIG_JBD_DEBUG
  244. int dropped = info.end_transaction - be32_to_cpu(sb->s_sequence);
  245. #endif
  246. jbd_debug(0,
  247. "JBD: ignoring %d transaction%s from the journal.\n",
  248. dropped, (dropped == 1) ? "" : "s");
  249. journal->j_transaction_sequence = ++info.end_transaction;
  250. }
  251. journal->j_tail = 0;
  252. return err;
  253. }
  254. static inline unsigned long long read_tag_block(int tag_bytes, journal_block_tag_t *tag)
  255. {
  256. unsigned long long block = be32_to_cpu(tag->t_blocknr);
  257. if (tag_bytes > JBD_TAG_SIZE32)
  258. block |= (u64)be32_to_cpu(tag->t_blocknr_high) << 32;
  259. return block;
  260. }
  261. static int do_one_pass(journal_t *journal,
  262. struct recovery_info *info, enum passtype pass)
  263. {
  264. unsigned int first_commit_ID, next_commit_ID;
  265. unsigned long next_log_block;
  266. int err, success = 0;
  267. journal_superblock_t * sb;
  268. journal_header_t * tmp;
  269. struct buffer_head * bh;
  270. unsigned int sequence;
  271. int blocktype;
  272. int tag_bytes = journal_tag_bytes(journal);
  273. /* Precompute the maximum metadata descriptors in a descriptor block */
  274. int MAX_BLOCKS_PER_DESC;
  275. MAX_BLOCKS_PER_DESC = ((journal->j_blocksize-sizeof(journal_header_t))
  276. / tag_bytes);
  277. /*
  278. * First thing is to establish what we expect to find in the log
  279. * (in terms of transaction IDs), and where (in terms of log
  280. * block offsets): query the superblock.
  281. */
  282. sb = journal->j_superblock;
  283. next_commit_ID = be32_to_cpu(sb->s_sequence);
  284. next_log_block = be32_to_cpu(sb->s_start);
  285. first_commit_ID = next_commit_ID;
  286. if (pass == PASS_SCAN)
  287. info->start_transaction = first_commit_ID;
  288. jbd_debug(1, "Starting recovery pass %d\n", pass);
  289. /*
  290. * Now we walk through the log, transaction by transaction,
  291. * making sure that each transaction has a commit block in the
  292. * expected place. Each complete transaction gets replayed back
  293. * into the main filesystem.
  294. */
  295. while (1) {
  296. int flags;
  297. char * tagp;
  298. journal_block_tag_t * tag;
  299. struct buffer_head * obh;
  300. struct buffer_head * nbh;
  301. cond_resched(); /* We're under lock_kernel() */
  302. /* If we already know where to stop the log traversal,
  303. * check right now that we haven't gone past the end of
  304. * the log. */
  305. if (pass != PASS_SCAN)
  306. if (tid_geq(next_commit_ID, info->end_transaction))
  307. break;
  308. jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n",
  309. next_commit_ID, next_log_block, journal->j_last);
  310. /* Skip over each chunk of the transaction looking
  311. * either the next descriptor block or the final commit
  312. * record. */
  313. jbd_debug(3, "JBD: checking block %ld\n", next_log_block);
  314. err = jread(&bh, journal, next_log_block);
  315. if (err)
  316. goto failed;
  317. next_log_block++;
  318. wrap(journal, next_log_block);
  319. /* What kind of buffer is it?
  320. *
  321. * If it is a descriptor block, check that it has the
  322. * expected sequence number. Otherwise, we're all done
  323. * here. */
  324. tmp = (journal_header_t *)bh->b_data;
  325. if (tmp->h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER)) {
  326. brelse(bh);
  327. break;
  328. }
  329. blocktype = be32_to_cpu(tmp->h_blocktype);
  330. sequence = be32_to_cpu(tmp->h_sequence);
  331. jbd_debug(3, "Found magic %d, sequence %d\n",
  332. blocktype, sequence);
  333. if (sequence != next_commit_ID) {
  334. brelse(bh);
  335. break;
  336. }
  337. /* OK, we have a valid descriptor block which matches
  338. * all of the sequence number checks. What are we going
  339. * to do with it? That depends on the pass... */
  340. switch(blocktype) {
  341. case JBD2_DESCRIPTOR_BLOCK:
  342. /* If it is a valid descriptor block, replay it
  343. * in pass REPLAY; otherwise, just skip over the
  344. * blocks it describes. */
  345. if (pass != PASS_REPLAY) {
  346. next_log_block += count_tags(journal, bh);
  347. wrap(journal, next_log_block);
  348. brelse(bh);
  349. continue;
  350. }
  351. /* A descriptor block: we can now write all of
  352. * the data blocks. Yay, useful work is finally
  353. * getting done here! */
  354. tagp = &bh->b_data[sizeof(journal_header_t)];
  355. while ((tagp - bh->b_data + tag_bytes)
  356. <= journal->j_blocksize) {
  357. unsigned long io_block;
  358. tag = (journal_block_tag_t *) tagp;
  359. flags = be32_to_cpu(tag->t_flags);
  360. io_block = next_log_block++;
  361. wrap(journal, next_log_block);
  362. err = jread(&obh, journal, io_block);
  363. if (err) {
  364. /* Recover what we can, but
  365. * report failure at the end. */
  366. success = err;
  367. printk (KERN_ERR
  368. "JBD: IO error %d recovering "
  369. "block %ld in log\n",
  370. err, io_block);
  371. } else {
  372. unsigned long long blocknr;
  373. J_ASSERT(obh != NULL);
  374. blocknr = read_tag_block(tag_bytes,
  375. tag);
  376. /* If the block has been
  377. * revoked, then we're all done
  378. * here. */
  379. if (jbd2_journal_test_revoke
  380. (journal, blocknr,
  381. next_commit_ID)) {
  382. brelse(obh);
  383. ++info->nr_revoke_hits;
  384. goto skip_write;
  385. }
  386. /* Find a buffer for the new
  387. * data being restored */
  388. nbh = __getblk(journal->j_fs_dev,
  389. blocknr,
  390. journal->j_blocksize);
  391. if (nbh == NULL) {
  392. printk(KERN_ERR
  393. "JBD: Out of memory "
  394. "during recovery.\n");
  395. err = -ENOMEM;
  396. brelse(bh);
  397. brelse(obh);
  398. goto failed;
  399. }
  400. lock_buffer(nbh);
  401. memcpy(nbh->b_data, obh->b_data,
  402. journal->j_blocksize);
  403. if (flags & JBD2_FLAG_ESCAPE) {
  404. *((__be32 *)bh->b_data) =
  405. cpu_to_be32(JBD2_MAGIC_NUMBER);
  406. }
  407. BUFFER_TRACE(nbh, "marking dirty");
  408. set_buffer_uptodate(nbh);
  409. mark_buffer_dirty(nbh);
  410. BUFFER_TRACE(nbh, "marking uptodate");
  411. ++info->nr_replays;
  412. /* ll_rw_block(WRITE, 1, &nbh); */
  413. unlock_buffer(nbh);
  414. brelse(obh);
  415. brelse(nbh);
  416. }
  417. skip_write:
  418. tagp += tag_bytes;
  419. if (!(flags & JBD2_FLAG_SAME_UUID))
  420. tagp += 16;
  421. if (flags & JBD2_FLAG_LAST_TAG)
  422. break;
  423. }
  424. brelse(bh);
  425. continue;
  426. case JBD2_COMMIT_BLOCK:
  427. /* Found an expected commit block: not much to
  428. * do other than move on to the next sequence
  429. * number. */
  430. brelse(bh);
  431. next_commit_ID++;
  432. continue;
  433. case JBD2_REVOKE_BLOCK:
  434. /* If we aren't in the REVOKE pass, then we can
  435. * just skip over this block. */
  436. if (pass != PASS_REVOKE) {
  437. brelse(bh);
  438. continue;
  439. }
  440. err = scan_revoke_records(journal, bh,
  441. next_commit_ID, info);
  442. brelse(bh);
  443. if (err)
  444. goto failed;
  445. continue;
  446. default:
  447. jbd_debug(3, "Unrecognised magic %d, end of scan.\n",
  448. blocktype);
  449. brelse(bh);
  450. goto done;
  451. }
  452. }
  453. done:
  454. /*
  455. * We broke out of the log scan loop: either we came to the
  456. * known end of the log or we found an unexpected block in the
  457. * log. If the latter happened, then we know that the "current"
  458. * transaction marks the end of the valid log.
  459. */
  460. if (pass == PASS_SCAN)
  461. info->end_transaction = next_commit_ID;
  462. else {
  463. /* It's really bad news if different passes end up at
  464. * different places (but possible due to IO errors). */
  465. if (info->end_transaction != next_commit_ID) {
  466. printk (KERN_ERR "JBD: recovery pass %d ended at "
  467. "transaction %u, expected %u\n",
  468. pass, next_commit_ID, info->end_transaction);
  469. if (!success)
  470. success = -EIO;
  471. }
  472. }
  473. return success;
  474. failed:
  475. return err;
  476. }
  477. /* Scan a revoke record, marking all blocks mentioned as revoked. */
  478. static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
  479. tid_t sequence, struct recovery_info *info)
  480. {
  481. jbd2_journal_revoke_header_t *header;
  482. int offset, max;
  483. int record_len = 4;
  484. header = (jbd2_journal_revoke_header_t *) bh->b_data;
  485. offset = sizeof(jbd2_journal_revoke_header_t);
  486. max = be32_to_cpu(header->r_count);
  487. if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
  488. record_len = 8;
  489. while (offset + record_len <= max) {
  490. unsigned long long blocknr;
  491. int err;
  492. if (record_len == 4)
  493. blocknr = be32_to_cpu(* ((__be32 *) (bh->b_data+offset)));
  494. else
  495. blocknr = be64_to_cpu(* ((__be64 *) (bh->b_data+offset)));
  496. offset += record_len;
  497. err = jbd2_journal_set_revoke(journal, blocknr, sequence);
  498. if (err)
  499. return err;
  500. ++info->nr_revokes;
  501. }
  502. return 0;
  503. }