Branch data Line data Source code
1 : : /*
2 : : * linux/fs/jbd2/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 : :
16 : : #ifndef __KERNEL__
17 : : #include "jfs_user.h"
18 : : #else
19 : : #include <linux/time.h>
20 : : #include <linux/fs.h>
21 : : #include <linux/jbd2.h>
22 : : #include <linux/errno.h>
23 : : #include <linux/crc32.h>
24 : : #include <linux/blkdev.h>
25 : : #endif
26 : :
27 : : /*
28 : : * Maintain information about the progress of the recovery job, so that
29 : : * the different passes can carry information between them.
30 : : */
31 : : struct recovery_info
32 : : {
33 : : tid_t start_transaction;
34 : : tid_t end_transaction;
35 : :
36 : : int nr_replays;
37 : : int nr_revokes;
38 : : int nr_revoke_hits;
39 : : };
40 : :
41 : : enum passtype {PASS_SCAN, PASS_REVOKE, PASS_REPLAY};
42 : : static int do_one_pass(journal_t *journal,
43 : : struct recovery_info *info, enum passtype pass);
44 : : static int scan_revoke_records(journal_t *, struct buffer_head *,
45 : : tid_t, struct recovery_info *);
46 : :
47 : : #ifdef __KERNEL__
48 : :
49 : : /* Release readahead buffers after use */
50 : 0 : static void journal_brelse_array(struct buffer_head *b[], int n)
51 : : {
52 [ # # ]: 0 : while (--n >= 0)
53 : 0 : brelse (b[n]);
54 : 0 : }
55 : :
56 : :
57 : : /*
58 : : * When reading from the journal, we are going through the block device
59 : : * layer directly and so there is no readahead being done for us. We
60 : : * need to implement any readahead ourselves if we want it to happen at
61 : : * all. Recovery is basically one long sequential read, so make sure we
62 : : * do the IO in reasonably large chunks.
63 : : *
64 : : * This is not so critical that we need to be enormously clever about
65 : : * the readahead size, though. 128K is a purely arbitrary, good-enough
66 : : * fixed value.
67 : : */
68 : :
69 : : #define MAXBUF 8
70 : 0 : static int do_readahead(journal_t *journal, unsigned int start)
71 : : {
72 : : int err;
73 : : unsigned int max, nbufs, next;
74 : : unsigned long long blocknr;
75 : : struct buffer_head *bh;
76 : :
77 : : struct buffer_head * bufs[MAXBUF];
78 : :
79 : : /* Do up to 128K of readahead */
80 : 0 : max = start + (128 * 1024 / journal->j_blocksize);
81 [ # # ]: 0 : if (max > journal->j_maxlen)
82 : : max = journal->j_maxlen;
83 : :
84 : : /* Do the readahead itself. We'll submit MAXBUF buffer_heads at
85 : : * a time to the block device IO layer. */
86 : :
87 : : nbufs = 0;
88 : :
89 [ # # ]: 0 : for (next = start; next < max; next++) {
90 : 0 : err = jbd2_journal_bmap(journal, next, &blocknr);
91 : :
92 [ # # ]: 0 : if (err) {
93 : 0 : printk(KERN_ERR "JBD2: bad block at offset %u\n",
94 : : next);
95 : 0 : goto failed;
96 : : }
97 : :
98 : 0 : bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
99 [ # # ]: 0 : if (!bh) {
100 : : err = -ENOMEM;
101 : : goto failed;
102 : : }
103 : :
104 [ # # ][ # # ]: 0 : if (!buffer_uptodate(bh) && !buffer_locked(bh)) {
105 : 0 : bufs[nbufs++] = bh;
106 [ # # ]: 0 : if (nbufs == MAXBUF) {
107 : 0 : ll_rw_block(READ, nbufs, bufs);
108 : 0 : journal_brelse_array(bufs, nbufs);
109 : : nbufs = 0;
110 : : }
111 : : } else
112 : : brelse(bh);
113 : : }
114 : :
115 [ # # ]: 0 : if (nbufs)
116 : 0 : ll_rw_block(READ, nbufs, bufs);
117 : : err = 0;
118 : :
119 : : failed:
120 [ # # ]: 0 : if (nbufs)
121 : 0 : journal_brelse_array(bufs, nbufs);
122 : 0 : return err;
123 : : }
124 : :
125 : : #endif /* __KERNEL__ */
126 : :
127 : :
128 : : /*
129 : : * Read a block from the journal
130 : : */
131 : :
132 : 0 : static int jread(struct buffer_head **bhp, journal_t *journal,
133 : : unsigned int offset)
134 : : {
135 : : int err;
136 : : unsigned long long blocknr;
137 : : struct buffer_head *bh;
138 : :
139 : 0 : *bhp = NULL;
140 : :
141 [ # # ]: 0 : if (offset >= journal->j_maxlen) {
142 : 0 : printk(KERN_ERR "JBD2: corrupted journal superblock\n");
143 : 0 : return -EIO;
144 : : }
145 : :
146 : 0 : err = jbd2_journal_bmap(journal, offset, &blocknr);
147 : :
148 [ # # ]: 0 : if (err) {
149 : 0 : printk(KERN_ERR "JBD2: bad block at offset %u\n",
150 : : offset);
151 : 0 : return err;
152 : : }
153 : :
154 : 0 : bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
155 [ # # ]: 0 : if (!bh)
156 : : return -ENOMEM;
157 : :
158 [ # # ]: 0 : if (!buffer_uptodate(bh)) {
159 : : /* If this is a brand new buffer, start readahead.
160 : : Otherwise, we assume we are already reading it. */
161 [ # # ]: 0 : if (!buffer_req(bh))
162 : 0 : do_readahead(journal, offset);
163 : : wait_on_buffer(bh);
164 : : }
165 : :
166 [ # # ]: 0 : if (!buffer_uptodate(bh)) {
167 : 0 : printk(KERN_ERR "JBD2: Failed to read block at offset %u\n",
168 : : offset);
169 : : brelse(bh);
170 : : return -EIO;
171 : : }
172 : :
173 : 0 : *bhp = bh;
174 : 0 : return 0;
175 : : }
176 : :
177 : 0 : static int jbd2_descr_block_csum_verify(journal_t *j,
178 : : void *buf)
179 : : {
180 : : struct jbd2_journal_block_tail *tail;
181 : : __be32 provided;
182 : : __u32 calculated;
183 : :
184 [ # # ][ # # ]: 0 : if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
185 : : return 1;
186 : :
187 : 0 : tail = (struct jbd2_journal_block_tail *)(buf + j->j_blocksize -
188 : : sizeof(struct jbd2_journal_block_tail));
189 : 0 : provided = tail->t_checksum;
190 : 0 : tail->t_checksum = 0;
191 : 0 : calculated = jbd2_chksum(j, j->j_csum_seed, buf, j->j_blocksize);
192 : 0 : tail->t_checksum = provided;
193 : :
194 [ # # ]: 0 : return provided == cpu_to_be32(calculated);
195 : : }
196 : :
197 : : /*
198 : : * Count the number of in-use tags in a journal descriptor block.
199 : : */
200 : :
201 : 0 : static int count_tags(journal_t *journal, struct buffer_head *bh)
202 : : {
203 : : char * tagp;
204 : : journal_block_tag_t * tag;
205 : 0 : int nr = 0, size = journal->j_blocksize;
206 : 0 : int tag_bytes = journal_tag_bytes(journal);
207 : :
208 [ # # ][ # # ]: 0 : if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2))
209 : 0 : size -= sizeof(struct jbd2_journal_block_tail);
210 : :
211 : 0 : tagp = &bh->b_data[sizeof(journal_header_t)];
212 : :
213 [ # # ]: 0 : while ((tagp - bh->b_data + tag_bytes) <= size) {
214 : : tag = (journal_block_tag_t *) tagp;
215 : :
216 : 0 : nr++;
217 : 0 : tagp += tag_bytes;
218 [ # # ]: 0 : if (!(tag->t_flags & cpu_to_be16(JBD2_FLAG_SAME_UUID)))
219 : 0 : tagp += 16;
220 : :
221 [ # # ]: 0 : if (tag->t_flags & cpu_to_be16(JBD2_FLAG_LAST_TAG))
222 : : break;
223 : : }
224 : :
225 : 0 : return nr;
226 : : }
227 : :
228 : :
229 : : /* Make sure we wrap around the log correctly! */
230 : : #define wrap(journal, var) \
231 : : do { \
232 : : if (var >= (journal)->j_last) \
233 : : var -= ((journal)->j_last - (journal)->j_first); \
234 : : } while (0)
235 : :
236 : : /**
237 : : * jbd2_journal_recover - recovers a on-disk journal
238 : : * @journal: the journal to recover
239 : : *
240 : : * The primary function for recovering the log contents when mounting a
241 : : * journaled device.
242 : : *
243 : : * Recovery is done in three passes. In the first pass, we look for the
244 : : * end of the log. In the second, we assemble the list of revoke
245 : : * blocks. In the third and final pass, we replay any un-revoked blocks
246 : : * in the log.
247 : : */
248 : 0 : int jbd2_journal_recover(journal_t *journal)
249 : : {
250 : : int err, err2;
251 : : journal_superblock_t * sb;
252 : :
253 : : struct recovery_info info;
254 : :
255 : 0 : memset(&info, 0, sizeof(info));
256 : 0 : sb = journal->j_superblock;
257 : :
258 : : /*
259 : : * The journal superblock's s_start field (the current log head)
260 : : * is always zero if, and only if, the journal was cleanly
261 : : * unmounted.
262 : : */
263 : :
264 [ # # ]: 0 : if (!sb->s_start) {
265 : : jbd_debug(1, "No recovery required, last transaction %d\n",
266 : : be32_to_cpu(sb->s_sequence));
267 [ # # ]: 0 : journal->j_transaction_sequence = be32_to_cpu(sb->s_sequence) + 1;
268 : 0 : return 0;
269 : : }
270 : :
271 : 0 : err = do_one_pass(journal, &info, PASS_SCAN);
272 [ # # ]: 0 : if (!err)
273 : 0 : err = do_one_pass(journal, &info, PASS_REVOKE);
274 [ # # ]: 0 : if (!err)
275 : 0 : err = do_one_pass(journal, &info, PASS_REPLAY);
276 : :
277 : : jbd_debug(1, "JBD2: recovery, exit status %d, "
278 : : "recovered transactions %u to %u\n",
279 : : err, info.start_transaction, info.end_transaction);
280 : : jbd_debug(1, "JBD2: Replayed %d and revoked %d/%d blocks\n",
281 : : info.nr_replays, info.nr_revoke_hits, info.nr_revokes);
282 : :
283 : : /* Restart the log at the next transaction ID, thus invalidating
284 : : * any existing commit records in the log. */
285 : 0 : journal->j_transaction_sequence = ++info.end_transaction;
286 : :
287 : 0 : jbd2_journal_clear_revoke(journal);
288 : 0 : err2 = sync_blockdev(journal->j_fs_dev);
289 [ # # ]: 0 : if (!err)
290 : : err = err2;
291 : : /* Make sure all replayed data is on permanent storage */
292 [ # # ]: 0 : if (journal->j_flags & JBD2_BARRIER) {
293 : 0 : err2 = blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL);
294 [ # # ]: 0 : if (!err)
295 : : err = err2;
296 : : }
297 : 0 : return err;
298 : : }
299 : :
300 : : /**
301 : : * jbd2_journal_skip_recovery - Start journal and wipe exiting records
302 : : * @journal: journal to startup
303 : : *
304 : : * Locate any valid recovery information from the journal and set up the
305 : : * journal structures in memory to ignore it (presumably because the
306 : : * caller has evidence that it is out of date).
307 : : * This function does'nt appear to be exorted..
308 : : *
309 : : * We perform one pass over the journal to allow us to tell the user how
310 : : * much recovery information is being erased, and to let us initialise
311 : : * the journal transaction sequence numbers to the next unused ID.
312 : : */
313 : 0 : int jbd2_journal_skip_recovery(journal_t *journal)
314 : : {
315 : : int err;
316 : :
317 : : struct recovery_info info;
318 : :
319 : 0 : memset (&info, 0, sizeof(info));
320 : :
321 : 0 : err = do_one_pass(journal, &info, PASS_SCAN);
322 : :
323 [ # # ]: 0 : if (err) {
324 : 0 : printk(KERN_ERR "JBD2: error %d scanning journal\n", err);
325 : 0 : ++journal->j_transaction_sequence;
326 : : } else {
327 : : #ifdef CONFIG_JBD2_DEBUG
328 : : int dropped = info.end_transaction -
329 : : be32_to_cpu(journal->j_superblock->s_sequence);
330 : : jbd_debug(1,
331 : : "JBD2: ignoring %d transaction%s from the journal.\n",
332 : : dropped, (dropped == 1) ? "" : "s");
333 : : #endif
334 : 0 : journal->j_transaction_sequence = ++info.end_transaction;
335 : : }
336 : :
337 : 0 : journal->j_tail = 0;
338 : 0 : return err;
339 : : }
340 : :
341 : : static inline unsigned long long read_tag_block(int tag_bytes, journal_block_tag_t *tag)
342 : : {
343 [ # # ]: 0 : unsigned long long block = be32_to_cpu(tag->t_blocknr);
344 [ # # ]: 0 : if (tag_bytes > JBD2_TAG_SIZE32)
345 [ # # ]: 0 : block |= (u64)be32_to_cpu(tag->t_blocknr_high) << 32;
346 : : return block;
347 : : }
348 : :
349 : : /*
350 : : * calc_chksums calculates the checksums for the blocks described in the
351 : : * descriptor block.
352 : : */
353 : 0 : static int calc_chksums(journal_t *journal, struct buffer_head *bh,
354 : : unsigned long *next_log_block, __u32 *crc32_sum)
355 : : {
356 : : int i, num_blks, err;
357 : : unsigned long io_block;
358 : : struct buffer_head *obh;
359 : :
360 : 0 : num_blks = count_tags(journal, bh);
361 : : /* Calculate checksum of the descriptor block. */
362 : 0 : *crc32_sum = crc32_be(*crc32_sum, (void *)bh->b_data, bh->b_size);
363 : :
364 [ # # ]: 0 : for (i = 0; i < num_blks; i++) {
365 : 0 : io_block = (*next_log_block)++;
366 [ # # ]: 0 : wrap(journal, *next_log_block);
367 : 0 : err = jread(&obh, journal, io_block);
368 [ # # ]: 0 : if (err) {
369 : 0 : printk(KERN_ERR "JBD2: IO error %d recovering block "
370 : : "%lu in log\n", err, io_block);
371 : 0 : return 1;
372 : : } else {
373 : 0 : *crc32_sum = crc32_be(*crc32_sum, (void *)obh->b_data,
374 : : obh->b_size);
375 : : }
376 : 0 : put_bh(obh);
377 : : }
378 : : return 0;
379 : : }
380 : :
381 : 0 : static int jbd2_commit_block_csum_verify(journal_t *j, void *buf)
382 : : {
383 : : struct commit_header *h;
384 : : __be32 provided;
385 : : __u32 calculated;
386 : :
387 [ # # ][ # # ]: 0 : if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
388 : : return 1;
389 : :
390 : : h = buf;
391 : 0 : provided = h->h_chksum[0];
392 : 0 : h->h_chksum[0] = 0;
393 : 0 : calculated = jbd2_chksum(j, j->j_csum_seed, buf, j->j_blocksize);
394 : 0 : h->h_chksum[0] = provided;
395 : :
396 [ # # ]: 0 : return provided == cpu_to_be32(calculated);
397 : : }
398 : :
399 : 0 : static int jbd2_block_tag_csum_verify(journal_t *j, journal_block_tag_t *tag,
400 : : void *buf, __u32 sequence)
401 : : {
402 : : __u32 csum32;
403 : : __be32 seq;
404 : :
405 [ # # ][ # # ]: 0 : if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
406 : : return 1;
407 : :
408 [ # # ]: 0 : seq = cpu_to_be32(sequence);
409 : 0 : csum32 = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&seq, sizeof(seq));
410 : 0 : csum32 = jbd2_chksum(j, csum32, buf, j->j_blocksize);
411 : :
412 [ # # ]: 0 : return tag->t_checksum == cpu_to_be16(csum32);
413 : : }
414 : :
415 : 0 : static int do_one_pass(journal_t *journal,
416 : : struct recovery_info *info, enum passtype pass)
417 : : {
418 : : unsigned int first_commit_ID, next_commit_ID;
419 : : unsigned long next_log_block;
420 : : int err, success = 0;
421 : : journal_superblock_t * sb;
422 : : journal_header_t * tmp;
423 : : struct buffer_head * bh;
424 : : unsigned int sequence;
425 : : int blocktype;
426 : 0 : int tag_bytes = journal_tag_bytes(journal);
427 : 0 : __u32 crc32_sum = ~0; /* Transactional Checksums */
428 : : int descr_csum_size = 0;
429 : :
430 : : /*
431 : : * First thing is to establish what we expect to find in the log
432 : : * (in terms of transaction IDs), and where (in terms of log
433 : : * block offsets): query the superblock.
434 : : */
435 : :
436 : 0 : sb = journal->j_superblock;
437 [ # # ]: 0 : next_commit_ID = be32_to_cpu(sb->s_sequence);
438 [ # # ]: 0 : next_log_block = be32_to_cpu(sb->s_start);
439 : :
440 : : first_commit_ID = next_commit_ID;
441 [ # # ]: 0 : if (pass == PASS_SCAN)
442 : 0 : info->start_transaction = first_commit_ID;
443 : :
444 : : jbd_debug(1, "Starting recovery pass %d\n", pass);
445 : :
446 : : /*
447 : : * Now we walk through the log, transaction by transaction,
448 : : * making sure that each transaction has a commit block in the
449 : : * expected place. Each complete transaction gets replayed back
450 : : * into the main filesystem.
451 : : */
452 : :
453 : : while (1) {
454 : : int flags;
455 : : char * tagp;
456 : 0 : journal_block_tag_t * tag;
457 : : struct buffer_head * obh;
458 : : struct buffer_head * nbh;
459 : :
460 : 0 : cond_resched();
461 : :
462 : : /* If we already know where to stop the log traversal,
463 : : * check right now that we haven't gone past the end of
464 : : * the log. */
465 : :
466 [ # # ]: 0 : if (pass != PASS_SCAN)
467 [ # # ]: 0 : if (tid_geq(next_commit_ID, info->end_transaction))
468 : : break;
469 : :
470 : : jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n",
471 : : next_commit_ID, next_log_block, journal->j_last);
472 : :
473 : : /* Skip over each chunk of the transaction looking
474 : : * either the next descriptor block or the final commit
475 : : * record. */
476 : :
477 : : jbd_debug(3, "JBD2: checking block %ld\n", next_log_block);
478 : 0 : err = jread(&bh, journal, next_log_block);
479 [ # # ]: 0 : if (err)
480 : : goto failed;
481 : :
482 : 0 : next_log_block++;
483 [ # # ]: 0 : wrap(journal, next_log_block);
484 : :
485 : : /* What kind of buffer is it?
486 : : *
487 : : * If it is a descriptor block, check that it has the
488 : : * expected sequence number. Otherwise, we're all done
489 : : * here. */
490 : :
491 : 0 : tmp = (journal_header_t *)bh->b_data;
492 : :
493 [ # # ]: 0 : if (tmp->h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER)) {
494 : : brelse(bh);
495 : : break;
496 : : }
497 : :
498 [ # # ]: 0 : blocktype = be32_to_cpu(tmp->h_blocktype);
499 [ # # ]: 0 : sequence = be32_to_cpu(tmp->h_sequence);
500 : : jbd_debug(3, "Found magic %d, sequence %d\n",
501 : : blocktype, sequence);
502 : :
503 [ # # ]: 0 : if (sequence != next_commit_ID) {
504 : : brelse(bh);
505 : : break;
506 : : }
507 : :
508 : : /* OK, we have a valid descriptor block which matches
509 : : * all of the sequence number checks. What are we going
510 : : * to do with it? That depends on the pass... */
511 : :
512 [ # # # # ]: 0 : switch(blocktype) {
513 : : case JBD2_DESCRIPTOR_BLOCK:
514 : : /* Verify checksum first */
515 [ # # ][ # # ]: 0 : if (JBD2_HAS_INCOMPAT_FEATURE(journal,
516 : : JBD2_FEATURE_INCOMPAT_CSUM_V2))
517 : : descr_csum_size =
518 : : sizeof(struct jbd2_journal_block_tail);
519 [ # # # # ]: 0 : if (descr_csum_size > 0 &&
520 : 0 : !jbd2_descr_block_csum_verify(journal,
521 : : bh->b_data)) {
522 : : err = -EIO;
523 : : goto failed;
524 : : }
525 : :
526 : : /* If it is a valid descriptor block, replay it
527 : : * in pass REPLAY; if journal_checksums enabled, then
528 : : * calculate checksums in PASS_SCAN, otherwise,
529 : : * just skip over the blocks it describes. */
530 [ # # ]: 0 : if (pass != PASS_REPLAY) {
531 [ # # ][ # # ]: 0 : if (pass == PASS_SCAN &&
532 [ # # ]: 0 : JBD2_HAS_COMPAT_FEATURE(journal,
533 [ # # ]: 0 : JBD2_FEATURE_COMPAT_CHECKSUM) &&
534 : 0 : !info->end_transaction) {
535 [ # # ]: 0 : if (calc_chksums(journal, bh,
536 : : &next_log_block,
537 : : &crc32_sum)) {
538 : 0 : put_bh(bh);
539 : : break;
540 : : }
541 : 0 : put_bh(bh);
542 : 0 : continue;
543 : : }
544 : 0 : next_log_block += count_tags(journal, bh);
545 [ # # ]: 0 : wrap(journal, next_log_block);
546 : 0 : put_bh(bh);
547 : 0 : continue;
548 : : }
549 : :
550 : : /* A descriptor block: we can now write all of
551 : : * the data blocks. Yay, useful work is finally
552 : : * getting done here! */
553 : :
554 : 0 : tagp = &bh->b_data[sizeof(journal_header_t)];
555 [ # # ]: 0 : while ((tagp - bh->b_data + tag_bytes)
556 : 0 : <= journal->j_blocksize - descr_csum_size) {
557 : : unsigned long io_block;
558 : :
559 : : tag = (journal_block_tag_t *) tagp;
560 [ # # ]: 0 : flags = be16_to_cpu(tag->t_flags);
561 : :
562 : 0 : io_block = next_log_block++;
563 [ # # ]: 0 : wrap(journal, next_log_block);
564 : 0 : err = jread(&obh, journal, io_block);
565 [ # # ]: 0 : if (err) {
566 : : /* Recover what we can, but
567 : : * report failure at the end. */
568 : : success = err;
569 : 0 : printk(KERN_ERR
570 : : "JBD2: IO error %d recovering "
571 : : "block %ld in log\n",
572 : : err, io_block);
573 : : } else {
574 : : unsigned long long blocknr;
575 : :
576 [ # # ]: 0 : J_ASSERT(obh != NULL);
577 : : blocknr = read_tag_block(tag_bytes,
578 : : tag);
579 : :
580 : : /* If the block has been
581 : : * revoked, then we're all done
582 : : * here. */
583 [ # # ]: 0 : if (jbd2_journal_test_revoke
584 : 0 : (journal, blocknr,
585 : : next_commit_ID)) {
586 : 0 : brelse(obh);
587 : 0 : ++info->nr_revoke_hits;
588 : 0 : goto skip_write;
589 : : }
590 : :
591 : : /* Look for block corruption */
592 [ # # ][ # # ]: 0 : if (!jbd2_block_tag_csum_verify(
593 : 0 : journal, tag, obh->b_data,
594 : 0 : be32_to_cpu(tmp->h_sequence))) {
595 : 0 : brelse(obh);
596 : : success = -EIO;
597 : 0 : printk(KERN_ERR "JBD2: Invalid "
598 : : "checksum recovering "
599 : : "block %llu in log\n",
600 : : blocknr);
601 : 0 : continue;
602 : : }
603 : :
604 : : /* Find a buffer for the new
605 : : * data being restored */
606 : 0 : nbh = __getblk(journal->j_fs_dev,
607 : : blocknr,
608 : 0 : journal->j_blocksize);
609 [ # # ]: 0 : if (nbh == NULL) {
610 : 0 : printk(KERN_ERR
611 : : "JBD2: Out of memory "
612 : : "during recovery.\n");
613 : : err = -ENOMEM;
614 : 0 : brelse(bh);
615 : 0 : brelse(obh);
616 : : goto failed;
617 : : }
618 : :
619 : : lock_buffer(nbh);
620 : 0 : memcpy(nbh->b_data, obh->b_data,
621 : 0 : journal->j_blocksize);
622 [ # # ]: 0 : if (flags & JBD2_FLAG_ESCAPE) {
623 : 0 : *((__be32 *)nbh->b_data) =
624 : : cpu_to_be32(JBD2_MAGIC_NUMBER);
625 : : }
626 : :
627 : : BUFFER_TRACE(nbh, "marking dirty");
628 : : set_buffer_uptodate(nbh);
629 : 0 : mark_buffer_dirty(nbh);
630 : : BUFFER_TRACE(nbh, "marking uptodate");
631 : 0 : ++info->nr_replays;
632 : : /* ll_rw_block(WRITE, 1, &nbh); */
633 : 0 : unlock_buffer(nbh);
634 : 0 : brelse(obh);
635 : : brelse(nbh);
636 : : }
637 : :
638 : : skip_write:
639 : 0 : tagp += tag_bytes;
640 [ # # ]: 0 : if (!(flags & JBD2_FLAG_SAME_UUID))
641 : 0 : tagp += 16;
642 : :
643 [ # # ]: 0 : if (flags & JBD2_FLAG_LAST_TAG)
644 : : break;
645 : : }
646 : :
647 : 0 : brelse(bh);
648 : 0 : continue;
649 : :
650 : : case JBD2_COMMIT_BLOCK:
651 : : /* How to differentiate between interrupted commit
652 : : * and journal corruption ?
653 : : *
654 : : * {nth transaction}
655 : : * Checksum Verification Failed
656 : : * |
657 : : * ____________________
658 : : * | |
659 : : * async_commit sync_commit
660 : : * | |
661 : : * | GO TO NEXT "Journal Corruption"
662 : : * | TRANSACTION
663 : : * |
664 : : * {(n+1)th transanction}
665 : : * |
666 : : * _______|______________
667 : : * | |
668 : : * Commit block found Commit block not found
669 : : * | |
670 : : * "Journal Corruption" |
671 : : * _____________|_________
672 : : * | |
673 : : * nth trans corrupt OR nth trans
674 : : * and (n+1)th interrupted interrupted
675 : : * before commit block
676 : : * could reach the disk.
677 : : * (Cannot find the difference in above
678 : : * mentioned conditions. Hence assume
679 : : * "Interrupted Commit".)
680 : : */
681 : :
682 : : /* Found an expected commit block: if checksums
683 : : * are present verify them in PASS_SCAN; else not
684 : : * much to do other than move on to the next sequence
685 : : * number. */
686 [ # # ][ # # ]: 0 : if (pass == PASS_SCAN &&
687 [ # # ]: 0 : JBD2_HAS_COMPAT_FEATURE(journal,
688 : : JBD2_FEATURE_COMPAT_CHECKSUM)) {
689 : : int chksum_err, chksum_seen;
690 : : struct commit_header *cbh =
691 : : (struct commit_header *)bh->b_data;
692 : : unsigned found_chksum =
693 [ # # ]: 0 : be32_to_cpu(cbh->h_chksum[0]);
694 : :
695 : : chksum_err = chksum_seen = 0;
696 : :
697 [ # # ]: 0 : if (info->end_transaction) {
698 : 0 : journal->j_failed_commit =
699 : : info->end_transaction;
700 : : brelse(bh);
701 : : break;
702 : : }
703 : :
704 [ # # ]: 0 : if (crc32_sum == found_chksum &&
705 [ # # ]: 0 : cbh->h_chksum_type == JBD2_CRC32_CHKSUM &&
706 : : cbh->h_chksum_size ==
707 : : JBD2_CRC32_CHKSUM_SIZE)
708 : : chksum_seen = 1;
709 [ # # ][ # # ]: 0 : else if (!(cbh->h_chksum_type == 0 &&
710 : : cbh->h_chksum_size == 0 &&
711 : : found_chksum == 0 &&
712 : : !chksum_seen))
713 : : /*
714 : : * If fs is mounted using an old kernel and then
715 : : * kernel with journal_chksum is used then we
716 : : * get a situation where the journal flag has
717 : : * checksum flag set but checksums are not
718 : : * present i.e chksum = 0, in the individual
719 : : * commit blocks.
720 : : * Hence to avoid checksum failures, in this
721 : : * situation, this extra check is added.
722 : : */
723 : : chksum_err = 1;
724 : :
725 [ # # ]: 0 : if (chksum_err) {
726 : 0 : info->end_transaction = next_commit_ID;
727 : :
728 [ # # ][ # # ]: 0 : if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
729 : : JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)){
730 : 0 : journal->j_failed_commit =
731 : : next_commit_ID;
732 : : brelse(bh);
733 : : break;
734 : : }
735 : : }
736 : 0 : crc32_sum = ~0;
737 : : }
738 [ # # # # ]: 0 : if (pass == PASS_SCAN &&
739 : 0 : !jbd2_commit_block_csum_verify(journal,
740 : 0 : bh->b_data)) {
741 : 0 : info->end_transaction = next_commit_ID;
742 : :
743 [ # # ][ # # ]: 0 : if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
744 : : JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
745 : 0 : journal->j_failed_commit =
746 : : next_commit_ID;
747 : 0 : brelse(bh);
748 : : break;
749 : : }
750 : : }
751 : 0 : brelse(bh);
752 : 0 : next_commit_ID++;
753 : 0 : continue;
754 : :
755 : : case JBD2_REVOKE_BLOCK:
756 : : /* If we aren't in the REVOKE pass, then we can
757 : : * just skip over this block. */
758 [ # # ]: 0 : if (pass != PASS_REVOKE) {
759 : : brelse(bh);
760 : 0 : continue;
761 : : }
762 : :
763 : 0 : err = scan_revoke_records(journal, bh,
764 : : next_commit_ID, info);
765 : 0 : brelse(bh);
766 [ # # ]: 0 : if (err)
767 : : goto failed;
768 : 0 : continue;
769 : :
770 : : default:
771 : : jbd_debug(3, "Unrecognised magic %d, end of scan.\n",
772 : : blocktype);
773 : : brelse(bh);
774 : 0 : goto done;
775 : : }
776 : : }
777 : :
778 : : done:
779 : : /*
780 : : * We broke out of the log scan loop: either we came to the
781 : : * known end of the log or we found an unexpected block in the
782 : : * log. If the latter happened, then we know that the "current"
783 : : * transaction marks the end of the valid log.
784 : : */
785 : :
786 [ # # ]: 0 : if (pass == PASS_SCAN) {
787 [ # # ]: 0 : if (!info->end_transaction)
788 : 0 : info->end_transaction = next_commit_ID;
789 : : } else {
790 : : /* It's really bad news if different passes end up at
791 : : * different places (but possible due to IO errors). */
792 [ # # ]: 0 : if (info->end_transaction != next_commit_ID) {
793 : 0 : printk(KERN_ERR "JBD2: recovery pass %d ended at "
794 : : "transaction %u, expected %u\n",
795 : : pass, next_commit_ID, info->end_transaction);
796 [ # # ]: 0 : if (!success)
797 : : success = -EIO;
798 : : }
799 : : }
800 : :
801 : 0 : return success;
802 : :
803 : : failed:
804 : 0 : return err;
805 : : }
806 : :
807 : 0 : static int jbd2_revoke_block_csum_verify(journal_t *j,
808 : : void *buf)
809 : : {
810 : : struct jbd2_journal_revoke_tail *tail;
811 : : __be32 provided;
812 : : __u32 calculated;
813 : :
814 [ # # ][ # # ]: 0 : if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
815 : : return 1;
816 : :
817 : 0 : tail = (struct jbd2_journal_revoke_tail *)(buf + j->j_blocksize -
818 : : sizeof(struct jbd2_journal_revoke_tail));
819 : 0 : provided = tail->r_checksum;
820 : 0 : tail->r_checksum = 0;
821 : 0 : calculated = jbd2_chksum(j, j->j_csum_seed, buf, j->j_blocksize);
822 : 0 : tail->r_checksum = provided;
823 : :
824 [ # # ]: 0 : return provided == cpu_to_be32(calculated);
825 : : }
826 : :
827 : : /* Scan a revoke record, marking all blocks mentioned as revoked. */
828 : :
829 : 0 : static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
830 : : tid_t sequence, struct recovery_info *info)
831 : : {
832 : : jbd2_journal_revoke_header_t *header;
833 : : int offset, max;
834 : : int record_len = 4;
835 : :
836 : 0 : header = (jbd2_journal_revoke_header_t *) bh->b_data;
837 : : offset = sizeof(jbd2_journal_revoke_header_t);
838 [ # # ]: 0 : max = be32_to_cpu(header->r_count);
839 : :
840 [ # # ]: 0 : if (!jbd2_revoke_block_csum_verify(journal, header))
841 : : return -EINVAL;
842 : :
843 [ # # ][ # # ]: 0 : if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
844 : : record_len = 8;
845 : :
846 [ # # ]: 0 : while (offset + record_len <= max) {
847 : : unsigned long long blocknr;
848 : : int err;
849 : :
850 [ # # ]: 0 : if (record_len == 4)
851 [ # # ]: 0 : blocknr = be32_to_cpu(* ((__be32 *) (bh->b_data+offset)));
852 : : else
853 [ # # ]: 0 : blocknr = be64_to_cpu(* ((__be64 *) (bh->b_data+offset)));
854 : : offset += record_len;
855 : 0 : err = jbd2_journal_set_revoke(journal, blocknr, sequence);
856 [ # # ]: 0 : if (err)
857 : : return err;
858 : 0 : ++info->nr_revokes;
859 : : }
860 : : return 0;
861 : : }
|
