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