recovery.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592
  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/jbd.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 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 = 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 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 = 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(struct buffer_head *bh, int size)
  148. {
  149. char * tagp;
  150. journal_block_tag_t * tag;
  151. int nr = 0;
  152. tagp = &bh->b_data[sizeof(journal_header_t)];
  153. while ((tagp - bh->b_data + sizeof(journal_block_tag_t)) <= size) {
  154. tag = (journal_block_tag_t *) tagp;
  155. nr++;
  156. tagp += sizeof(journal_block_tag_t);
  157. if (!(tag->t_flags & cpu_to_be32(JFS_FLAG_SAME_UUID)))
  158. tagp += 16;
  159. if (tag->t_flags & cpu_to_be32(JFS_FLAG_LAST_TAG))
  160. break;
  161. }
  162. return nr;
  163. }
  164. /* Make sure we wrap around the log correctly! */
  165. #define wrap(journal, var) \
  166. do { \
  167. if (var >= (journal)->j_last) \
  168. var -= ((journal)->j_last - (journal)->j_first); \
  169. } while (0)
  170. /**
  171. * journal_recover - recovers a on-disk journal
  172. * @journal: the journal to recover
  173. *
  174. * The primary function for recovering the log contents when mounting a
  175. * journaled device.
  176. *
  177. * Recovery is done in three passes. In the first pass, we look for the
  178. * end of the log. In the second, we assemble the list of revoke
  179. * blocks. In the third and final pass, we replay any un-revoked blocks
  180. * in the log.
  181. */
  182. int journal_recover(journal_t *journal)
  183. {
  184. int err;
  185. journal_superblock_t * sb;
  186. struct recovery_info info;
  187. memset(&info, 0, sizeof(info));
  188. sb = journal->j_superblock;
  189. /*
  190. * The journal superblock's s_start field (the current log head)
  191. * is always zero if, and only if, the journal was cleanly
  192. * unmounted.
  193. */
  194. if (!sb->s_start) {
  195. jbd_debug(1, "No recovery required, last transaction %d\n",
  196. be32_to_cpu(sb->s_sequence));
  197. journal->j_transaction_sequence = be32_to_cpu(sb->s_sequence) + 1;
  198. return 0;
  199. }
  200. err = do_one_pass(journal, &info, PASS_SCAN);
  201. if (!err)
  202. err = do_one_pass(journal, &info, PASS_REVOKE);
  203. if (!err)
  204. err = do_one_pass(journal, &info, PASS_REPLAY);
  205. jbd_debug(0, "JBD: recovery, exit status %d, "
  206. "recovered transactions %u to %u\n",
  207. err, info.start_transaction, info.end_transaction);
  208. jbd_debug(0, "JBD: Replayed %d and revoked %d/%d blocks\n",
  209. info.nr_replays, info.nr_revoke_hits, info.nr_revokes);
  210. /* Restart the log at the next transaction ID, thus invalidating
  211. * any existing commit records in the log. */
  212. journal->j_transaction_sequence = ++info.end_transaction;
  213. journal_clear_revoke(journal);
  214. sync_blockdev(journal->j_fs_dev);
  215. return err;
  216. }
  217. /**
  218. * journal_skip_recovery - Start journal and wipe exiting records
  219. * @journal: journal to startup
  220. *
  221. * Locate any valid recovery information from the journal and set up the
  222. * journal structures in memory to ignore it (presumably because the
  223. * caller has evidence that it is out of date).
  224. * This function does'nt appear to be exorted..
  225. *
  226. * We perform one pass over the journal to allow us to tell the user how
  227. * much recovery information is being erased, and to let us initialise
  228. * the journal transaction sequence numbers to the next unused ID.
  229. */
  230. int journal_skip_recovery(journal_t *journal)
  231. {
  232. int err;
  233. journal_superblock_t * sb;
  234. struct recovery_info info;
  235. memset (&info, 0, sizeof(info));
  236. sb = journal->j_superblock;
  237. err = do_one_pass(journal, &info, PASS_SCAN);
  238. if (err) {
  239. printk(KERN_ERR "JBD: error %d scanning journal\n", err);
  240. ++journal->j_transaction_sequence;
  241. } else {
  242. #ifdef CONFIG_JBD_DEBUG
  243. int dropped = info.end_transaction - be32_to_cpu(sb->s_sequence);
  244. #endif
  245. jbd_debug(0,
  246. "JBD: ignoring %d transaction%s from the journal.\n",
  247. dropped, (dropped == 1) ? "" : "s");
  248. journal->j_transaction_sequence = ++info.end_transaction;
  249. }
  250. journal->j_tail = 0;
  251. return err;
  252. }
  253. static int do_one_pass(journal_t *journal,
  254. struct recovery_info *info, enum passtype pass)
  255. {
  256. unsigned int first_commit_ID, next_commit_ID;
  257. unsigned long next_log_block;
  258. int err, success = 0;
  259. journal_superblock_t * sb;
  260. journal_header_t * tmp;
  261. struct buffer_head * bh;
  262. unsigned int sequence;
  263. int blocktype;
  264. /* Precompute the maximum metadata descriptors in a descriptor block */
  265. int MAX_BLOCKS_PER_DESC;
  266. MAX_BLOCKS_PER_DESC = ((journal->j_blocksize-sizeof(journal_header_t))
  267. / sizeof(journal_block_tag_t));
  268. /*
  269. * First thing is to establish what we expect to find in the log
  270. * (in terms of transaction IDs), and where (in terms of log
  271. * block offsets): query the superblock.
  272. */
  273. sb = journal->j_superblock;
  274. next_commit_ID = be32_to_cpu(sb->s_sequence);
  275. next_log_block = be32_to_cpu(sb->s_start);
  276. first_commit_ID = next_commit_ID;
  277. if (pass == PASS_SCAN)
  278. info->start_transaction = first_commit_ID;
  279. jbd_debug(1, "Starting recovery pass %d\n", pass);
  280. /*
  281. * Now we walk through the log, transaction by transaction,
  282. * making sure that each transaction has a commit block in the
  283. * expected place. Each complete transaction gets replayed back
  284. * into the main filesystem.
  285. */
  286. while (1) {
  287. int flags;
  288. char * tagp;
  289. journal_block_tag_t * tag;
  290. struct buffer_head * obh;
  291. struct buffer_head * nbh;
  292. cond_resched(); /* We're under lock_kernel() */
  293. /* If we already know where to stop the log traversal,
  294. * check right now that we haven't gone past the end of
  295. * the log. */
  296. if (pass != PASS_SCAN)
  297. if (tid_geq(next_commit_ID, info->end_transaction))
  298. break;
  299. jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n",
  300. next_commit_ID, next_log_block, journal->j_last);
  301. /* Skip over each chunk of the transaction looking
  302. * either the next descriptor block or the final commit
  303. * record. */
  304. jbd_debug(3, "JBD: checking block %ld\n", next_log_block);
  305. err = jread(&bh, journal, next_log_block);
  306. if (err)
  307. goto failed;
  308. next_log_block++;
  309. wrap(journal, next_log_block);
  310. /* What kind of buffer is it?
  311. *
  312. * If it is a descriptor block, check that it has the
  313. * expected sequence number. Otherwise, we're all done
  314. * here. */
  315. tmp = (journal_header_t *)bh->b_data;
  316. if (tmp->h_magic != cpu_to_be32(JFS_MAGIC_NUMBER)) {
  317. brelse(bh);
  318. break;
  319. }
  320. blocktype = be32_to_cpu(tmp->h_blocktype);
  321. sequence = be32_to_cpu(tmp->h_sequence);
  322. jbd_debug(3, "Found magic %d, sequence %d\n",
  323. blocktype, sequence);
  324. if (sequence != next_commit_ID) {
  325. brelse(bh);
  326. break;
  327. }
  328. /* OK, we have a valid descriptor block which matches
  329. * all of the sequence number checks. What are we going
  330. * to do with it? That depends on the pass... */
  331. switch(blocktype) {
  332. case JFS_DESCRIPTOR_BLOCK:
  333. /* If it is a valid descriptor block, replay it
  334. * in pass REPLAY; otherwise, just skip over the
  335. * blocks it describes. */
  336. if (pass != PASS_REPLAY) {
  337. next_log_block +=
  338. count_tags(bh, journal->j_blocksize);
  339. wrap(journal, next_log_block);
  340. brelse(bh);
  341. continue;
  342. }
  343. /* A descriptor block: we can now write all of
  344. * the data blocks. Yay, useful work is finally
  345. * getting done here! */
  346. tagp = &bh->b_data[sizeof(journal_header_t)];
  347. while ((tagp - bh->b_data +sizeof(journal_block_tag_t))
  348. <= journal->j_blocksize) {
  349. unsigned long io_block;
  350. tag = (journal_block_tag_t *) tagp;
  351. flags = be32_to_cpu(tag->t_flags);
  352. io_block = next_log_block++;
  353. wrap(journal, next_log_block);
  354. err = jread(&obh, journal, io_block);
  355. if (err) {
  356. /* Recover what we can, but
  357. * report failure at the end. */
  358. success = err;
  359. printk (KERN_ERR
  360. "JBD: IO error %d recovering "
  361. "block %ld in log\n",
  362. err, io_block);
  363. } else {
  364. unsigned long blocknr;
  365. J_ASSERT(obh != NULL);
  366. blocknr = be32_to_cpu(tag->t_blocknr);
  367. /* If the block has been
  368. * revoked, then we're all done
  369. * here. */
  370. if (journal_test_revoke
  371. (journal, blocknr,
  372. next_commit_ID)) {
  373. brelse(obh);
  374. ++info->nr_revoke_hits;
  375. goto skip_write;
  376. }
  377. /* Find a buffer for the new
  378. * data being restored */
  379. nbh = __getblk(journal->j_fs_dev,
  380. blocknr,
  381. journal->j_blocksize);
  382. if (nbh == NULL) {
  383. printk(KERN_ERR
  384. "JBD: Out of memory "
  385. "during recovery.\n");
  386. err = -ENOMEM;
  387. brelse(bh);
  388. brelse(obh);
  389. goto failed;
  390. }
  391. lock_buffer(nbh);
  392. memcpy(nbh->b_data, obh->b_data,
  393. journal->j_blocksize);
  394. if (flags & JFS_FLAG_ESCAPE) {
  395. *((__be32 *)bh->b_data) =
  396. cpu_to_be32(JFS_MAGIC_NUMBER);
  397. }
  398. BUFFER_TRACE(nbh, "marking dirty");
  399. set_buffer_uptodate(nbh);
  400. mark_buffer_dirty(nbh);
  401. BUFFER_TRACE(nbh, "marking uptodate");
  402. ++info->nr_replays;
  403. /* ll_rw_block(WRITE, 1, &nbh); */
  404. unlock_buffer(nbh);
  405. brelse(obh);
  406. brelse(nbh);
  407. }
  408. skip_write:
  409. tagp += sizeof(journal_block_tag_t);
  410. if (!(flags & JFS_FLAG_SAME_UUID))
  411. tagp += 16;
  412. if (flags & JFS_FLAG_LAST_TAG)
  413. break;
  414. }
  415. brelse(bh);
  416. continue;
  417. case JFS_COMMIT_BLOCK:
  418. /* Found an expected commit block: not much to
  419. * do other than move on to the next sequence
  420. * number. */
  421. brelse(bh);
  422. next_commit_ID++;
  423. continue;
  424. case JFS_REVOKE_BLOCK:
  425. /* If we aren't in the REVOKE pass, then we can
  426. * just skip over this block. */
  427. if (pass != PASS_REVOKE) {
  428. brelse(bh);
  429. continue;
  430. }
  431. err = scan_revoke_records(journal, bh,
  432. next_commit_ID, info);
  433. brelse(bh);
  434. if (err)
  435. goto failed;
  436. continue;
  437. default:
  438. jbd_debug(3, "Unrecognised magic %d, end of scan.\n",
  439. blocktype);
  440. brelse(bh);
  441. goto done;
  442. }
  443. }
  444. done:
  445. /*
  446. * We broke out of the log scan loop: either we came to the
  447. * known end of the log or we found an unexpected block in the
  448. * log. If the latter happened, then we know that the "current"
  449. * transaction marks the end of the valid log.
  450. */
  451. if (pass == PASS_SCAN)
  452. info->end_transaction = next_commit_ID;
  453. else {
  454. /* It's really bad news if different passes end up at
  455. * different places (but possible due to IO errors). */
  456. if (info->end_transaction != next_commit_ID) {
  457. printk (KERN_ERR "JBD: recovery pass %d ended at "
  458. "transaction %u, expected %u\n",
  459. pass, next_commit_ID, info->end_transaction);
  460. if (!success)
  461. success = -EIO;
  462. }
  463. }
  464. return success;
  465. failed:
  466. return err;
  467. }
  468. /* Scan a revoke record, marking all blocks mentioned as revoked. */
  469. static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
  470. tid_t sequence, struct recovery_info *info)
  471. {
  472. journal_revoke_header_t *header;
  473. int offset, max;
  474. header = (journal_revoke_header_t *) bh->b_data;
  475. offset = sizeof(journal_revoke_header_t);
  476. max = be32_to_cpu(header->r_count);
  477. while (offset < max) {
  478. unsigned long blocknr;
  479. int err;
  480. blocknr = be32_to_cpu(* ((__be32 *) (bh->b_data+offset)));
  481. offset += 4;
  482. err = journal_set_revoke(journal, blocknr, sequence);
  483. if (err)
  484. return err;
  485. ++info->nr_revokes;
  486. }
  487. return 0;
  488. }