Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6-block.git] / fs / gfs2 / recovery.c
CommitLineData
b3b94faa
DT
1/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3a8a9a10 3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
b3b94faa
DT
4 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
e9fc2aa0 7 * of the GNU General Public License version 2.
b3b94faa
DT
8 */
9
b3b94faa
DT
10#include <linux/slab.h>
11#include <linux/spinlock.h>
12#include <linux/completion.h>
13#include <linux/buffer_head.h>
5c676f6d 14#include <linux/gfs2_ondisk.h>
71b86f56 15#include <linux/crc32.h>
7d308590 16#include <linux/lm_interface.h>
b3b94faa
DT
17
18#include "gfs2.h"
5c676f6d 19#include "incore.h"
b3b94faa
DT
20#include "bmap.h"
21#include "glock.h"
22#include "glops.h"
b3b94faa
DT
23#include "lops.h"
24#include "meta_io.h"
25#include "recovery.h"
26#include "super.h"
5c676f6d 27#include "util.h"
71b86f56 28#include "dir.h"
b3b94faa
DT
29
30int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
31 struct buffer_head **bh)
32{
feaa7bba 33 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
5c676f6d 34 struct gfs2_glock *gl = ip->i_gl;
b3b94faa 35 int new = 0;
cd915493
SW
36 u64 dblock;
37 u32 extlen;
b3b94faa
DT
38 int error;
39
feaa7bba 40 error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen);
b3b94faa
DT
41 if (error)
42 return error;
43 if (!dblock) {
5c676f6d 44 gfs2_consist_inode(ip);
b3b94faa
DT
45 return -EIO;
46 }
47
7276b3b0 48 *bh = gfs2_meta_ra(gl, dblock, extlen);
b3b94faa
DT
49
50 return error;
51}
52
cd915493 53int gfs2_revoke_add(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
b3b94faa
DT
54{
55 struct list_head *head = &sdp->sd_revoke_list;
56 struct gfs2_revoke_replay *rr;
57 int found = 0;
58
59 list_for_each_entry(rr, head, rr_list) {
60 if (rr->rr_blkno == blkno) {
61 found = 1;
62 break;
63 }
64 }
65
66 if (found) {
67 rr->rr_where = where;
68 return 0;
69 }
70
16c5f06f 71 rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_NOFS);
b3b94faa
DT
72 if (!rr)
73 return -ENOMEM;
74
75 rr->rr_blkno = blkno;
76 rr->rr_where = where;
77 list_add(&rr->rr_list, head);
78
79 return 1;
80}
81
cd915493 82int gfs2_revoke_check(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
b3b94faa
DT
83{
84 struct gfs2_revoke_replay *rr;
85 int wrap, a, b, revoke;
86 int found = 0;
87
88 list_for_each_entry(rr, &sdp->sd_revoke_list, rr_list) {
89 if (rr->rr_blkno == blkno) {
90 found = 1;
91 break;
92 }
93 }
94
95 if (!found)
96 return 0;
97
98 wrap = (rr->rr_where < sdp->sd_replay_tail);
99 a = (sdp->sd_replay_tail < where);
100 b = (where < rr->rr_where);
101 revoke = (wrap) ? (a || b) : (a && b);
102
103 return revoke;
104}
105
106void gfs2_revoke_clean(struct gfs2_sbd *sdp)
107{
108 struct list_head *head = &sdp->sd_revoke_list;
109 struct gfs2_revoke_replay *rr;
110
111 while (!list_empty(head)) {
112 rr = list_entry(head->next, struct gfs2_revoke_replay, rr_list);
113 list_del(&rr->rr_list);
114 kfree(rr);
115 }
116}
117
bb8d8a6f
SW
118static int gfs2_log_header_in(struct gfs2_log_header_host *lh, const void *buf)
119{
120 const struct gfs2_log_header *str = buf;
121
122 if (str->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) ||
123 str->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH))
124 return 1;
125
126 lh->lh_sequence = be64_to_cpu(str->lh_sequence);
127 lh->lh_flags = be32_to_cpu(str->lh_flags);
128 lh->lh_tail = be32_to_cpu(str->lh_tail);
129 lh->lh_blkno = be32_to_cpu(str->lh_blkno);
130 lh->lh_hash = be32_to_cpu(str->lh_hash);
131 return 0;
132}
133
b3b94faa
DT
134/**
135 * get_log_header - read the log header for a given segment
136 * @jd: the journal
137 * @blk: the block to look at
138 * @lh: the log header to return
139 *
140 * Read the log header for a given segement in a given journal. Do a few
141 * sanity checks on it.
142 *
143 * Returns: 0 on success,
144 * 1 if the header was invalid or incomplete,
145 * errno on error
146 */
147
148static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
55167622 149 struct gfs2_log_header_host *head)
b3b94faa
DT
150{
151 struct buffer_head *bh;
f5a8cd02 152 struct gfs2_log_header_host uninitialized_var(lh);
887bc5d0 153 const u32 nothing = 0;
cd915493 154 u32 hash;
b3b94faa
DT
155 int error;
156
157 error = gfs2_replay_read_block(jd, blk, &bh);
158 if (error)
159 return error;
160
2a2c9824
SW
161 hash = crc32_le((u32)~0, bh->b_data, sizeof(struct gfs2_log_header) -
162 sizeof(u32));
163 hash = crc32_le(hash, (unsigned char const *)&nothing, sizeof(nothing));
164 hash ^= (u32)~0;
bb8d8a6f 165 error = gfs2_log_header_in(&lh, bh->b_data);
b3b94faa
DT
166 brelse(bh);
167
bb8d8a6f 168 if (error || lh.lh_blkno != blk || lh.lh_hash != hash)
b3b94faa
DT
169 return 1;
170
171 *head = lh;
172
173 return 0;
174}
175
176/**
177 * find_good_lh - find a good log header
178 * @jd: the journal
179 * @blk: the segment to start searching from
180 * @lh: the log header to fill in
181 * @forward: if true search forward in the log, else search backward
182 *
183 * Call get_log_header() to get a log header for a segment, but if the
184 * segment is bad, either scan forward or backward until we find a good one.
185 *
186 * Returns: errno
187 */
188
189static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
55167622 190 struct gfs2_log_header_host *head)
b3b94faa
DT
191{
192 unsigned int orig_blk = *blk;
193 int error;
194
195 for (;;) {
196 error = get_log_header(jd, *blk, head);
197 if (error <= 0)
198 return error;
199
200 if (++*blk == jd->jd_blocks)
201 *blk = 0;
202
203 if (*blk == orig_blk) {
feaa7bba 204 gfs2_consist_inode(GFS2_I(jd->jd_inode));
b3b94faa
DT
205 return -EIO;
206 }
207 }
208}
209
210/**
211 * jhead_scan - make sure we've found the head of the log
212 * @jd: the journal
213 * @head: this is filled in with the log descriptor of the head
214 *
215 * At this point, seg and lh should be either the head of the log or just
216 * before. Scan forward until we find the head.
217 *
218 * Returns: errno
219 */
220
55167622 221static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
b3b94faa
DT
222{
223 unsigned int blk = head->lh_blkno;
55167622 224 struct gfs2_log_header_host lh;
b3b94faa
DT
225 int error;
226
227 for (;;) {
228 if (++blk == jd->jd_blocks)
229 blk = 0;
230
231 error = get_log_header(jd, blk, &lh);
232 if (error < 0)
233 return error;
234 if (error == 1)
235 continue;
236
237 if (lh.lh_sequence == head->lh_sequence) {
feaa7bba 238 gfs2_consist_inode(GFS2_I(jd->jd_inode));
b3b94faa
DT
239 return -EIO;
240 }
241 if (lh.lh_sequence < head->lh_sequence)
242 break;
243
244 *head = lh;
245 }
246
247 return 0;
248}
249
250/**
251 * gfs2_find_jhead - find the head of a log
252 * @jd: the journal
253 * @head: the log descriptor for the head of the log is returned here
254 *
255 * Do a binary search of a journal and find the valid log entry with the
256 * highest sequence number. (i.e. the log head)
257 *
258 * Returns: errno
259 */
260
55167622 261int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
b3b94faa 262{
55167622 263 struct gfs2_log_header_host lh_1, lh_m;
cd915493 264 u32 blk_1, blk_2, blk_m;
b3b94faa
DT
265 int error;
266
267 blk_1 = 0;
268 blk_2 = jd->jd_blocks - 1;
269
270 for (;;) {
271 blk_m = (blk_1 + blk_2) / 2;
272
273 error = find_good_lh(jd, &blk_1, &lh_1);
274 if (error)
275 return error;
276
277 error = find_good_lh(jd, &blk_m, &lh_m);
278 if (error)
279 return error;
280
281 if (blk_1 == blk_m || blk_m == blk_2)
282 break;
283
284 if (lh_1.lh_sequence <= lh_m.lh_sequence)
285 blk_1 = blk_m;
286 else
287 blk_2 = blk_m;
288 }
289
290 error = jhead_scan(jd, &lh_1);
291 if (error)
292 return error;
293
294 *head = lh_1;
295
296 return error;
297}
298
299/**
300 * foreach_descriptor - go through the active part of the log
301 * @jd: the journal
302 * @start: the first log header in the active region
303 * @end: the last log header (don't process the contents of this entry))
304 *
305 * Call a given function once for every log descriptor in the active
306 * portion of the log.
307 *
308 * Returns: errno
309 */
310
311static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
312 unsigned int end, int pass)
313{
feaa7bba 314 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
b3b94faa
DT
315 struct buffer_head *bh;
316 struct gfs2_log_descriptor *ld;
317 int error = 0;
318 u32 length;
319 __be64 *ptr;
320 unsigned int offset = sizeof(struct gfs2_log_descriptor);
a67cdbd4
SW
321 offset += sizeof(__be64) - 1;
322 offset &= ~(sizeof(__be64) - 1);
b3b94faa
DT
323
324 while (start != end) {
325 error = gfs2_replay_read_block(jd, start, &bh);
326 if (error)
327 return error;
328 if (gfs2_meta_check(sdp, bh)) {
329 brelse(bh);
330 return -EIO;
331 }
332 ld = (struct gfs2_log_descriptor *)bh->b_data;
333 length = be32_to_cpu(ld->ld_length);
334
e3167ded 335 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
55167622 336 struct gfs2_log_header_host lh;
b3b94faa
DT
337 error = get_log_header(jd, start, &lh);
338 if (!error) {
339 gfs2_replay_incr_blk(sdp, &start);
88721877 340 brelse(bh);
b3b94faa
DT
341 continue;
342 }
343 if (error == 1) {
feaa7bba 344 gfs2_consist_inode(GFS2_I(jd->jd_inode));
b3b94faa
DT
345 error = -EIO;
346 }
347 brelse(bh);
348 return error;
349 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) {
350 brelse(bh);
351 return -EIO;
352 }
353 ptr = (__be64 *)(bh->b_data + offset);
354 error = lops_scan_elements(jd, start, ld, ptr, pass);
355 if (error) {
356 brelse(bh);
357 return error;
358 }
359
360 while (length--)
361 gfs2_replay_incr_blk(sdp, &start);
362
363 brelse(bh);
364 }
365
366 return 0;
367}
368
369/**
370 * clean_journal - mark a dirty journal as being clean
371 * @sdp: the filesystem
372 * @jd: the journal
373 * @gl: the journal's glock
374 * @head: the head journal to start from
375 *
376 * Returns: errno
377 */
378
55167622 379static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
b3b94faa 380{
feaa7bba
SW
381 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
382 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
b3b94faa 383 unsigned int lblock;
b3b94faa 384 struct gfs2_log_header *lh;
cd915493 385 u32 hash;
b3b94faa
DT
386 struct buffer_head *bh;
387 int error;
23591256 388 struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
fd88de56 389
b3b94faa
DT
390 lblock = head->lh_blkno;
391 gfs2_replay_incr_blk(sdp, &lblock);
23591256 392 bh_map.b_size = 1 << ip->i_inode.i_blkbits;
e9e1ef2b 393 error = gfs2_block_map(&ip->i_inode, lblock, &bh_map, 0);
b3b94faa
DT
394 if (error)
395 return error;
7a6bbacb 396 if (!bh_map.b_blocknr) {
b3b94faa
DT
397 gfs2_consist_inode(ip);
398 return -EIO;
399 }
400
7a6bbacb 401 bh = sb_getblk(sdp->sd_vfs, bh_map.b_blocknr);
b3b94faa
DT
402 lock_buffer(bh);
403 memset(bh->b_data, 0, bh->b_size);
404 set_buffer_uptodate(bh);
405 clear_buffer_dirty(bh);
406 unlock_buffer(bh);
407
408 lh = (struct gfs2_log_header *)bh->b_data;
409 memset(lh, 0, sizeof(struct gfs2_log_header));
410 lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
88721877 411 lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
e3167ded 412 lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
b3b94faa
DT
413 lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1);
414 lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
415 lh->lh_blkno = cpu_to_be32(lblock);
416 hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header));
417 lh->lh_hash = cpu_to_be32(hash);
418
419 set_buffer_dirty(bh);
420 if (sync_dirty_buffer(bh))
421 gfs2_io_error_bh(sdp, bh);
422 brelse(bh);
423
424 return error;
425}
426
da755fdb
SW
427
428static void gfs2_lm_recovery_done(struct gfs2_sbd *sdp, unsigned int jid,
429 unsigned int message)
430{
048bca22
SW
431 if (!sdp->sd_lockstruct.ls_ops->lm_recovery_done)
432 return;
433
da755fdb
SW
434 if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
435 sdp->sd_lockstruct.ls_ops->lm_recovery_done(
436 sdp->sd_lockstruct.ls_lockspace, jid, message);
437}
438
439
b3b94faa
DT
440/**
441 * gfs2_recover_journal - recovery a given journal
442 * @jd: the struct gfs2_jdesc describing the journal
b3b94faa
DT
443 *
444 * Acquire the journal's lock, check to see if the journal is clean, and
445 * do recovery if necessary.
446 *
447 * Returns: errno
448 */
449
c63e31c2 450int gfs2_recover_journal(struct gfs2_jdesc *jd)
b3b94faa 451{
feaa7bba
SW
452 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
453 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
55167622 454 struct gfs2_log_header_host head;
b3b94faa
DT
455 struct gfs2_holder j_gh, ji_gh, t_gh;
456 unsigned long t;
457 int ro = 0;
458 unsigned int pass;
459 int error;
460
5965b1f4
SW
461 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
462 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n",
463 jd->jd_jid);
b3b94faa 464
c78bad11 465 /* Acquire the journal lock so we can do recovery */
b3b94faa 466
5965b1f4
SW
467 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops,
468 LM_ST_EXCLUSIVE,
469 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE,
470 &j_gh);
471 switch (error) {
472 case 0:
473 break;
907b9bce 474
5965b1f4
SW
475 case GLR_TRYFAILED:
476 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
477 error = 0;
907b9bce 478
5965b1f4
SW
479 default:
480 goto fail;
481 };
b3b94faa 482
5965b1f4 483 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
75be73a8 484 LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh);
5965b1f4
SW
485 if (error)
486 goto fail_gunlock_j;
487 } else {
488 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid);
489 }
b3b94faa
DT
490
491 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid);
492
493 error = gfs2_jdesc_check(jd);
494 if (error)
495 goto fail_gunlock_ji;
496
497 error = gfs2_find_jhead(jd, &head);
498 if (error)
499 goto fail_gunlock_ji;
500
501 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
502 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n",
503 jd->jd_jid);
504
505 t = jiffies;
506
507 /* Acquire a shared hold on the transaction lock */
508
59a1cc6b 509 error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
5965b1f4 510 LM_FLAG_NOEXP | LM_FLAG_PRIORITY |
6802e340 511 GL_NOCACHE, &t_gh);
b3b94faa
DT
512 if (error)
513 goto fail_gunlock_ji;
514
515 if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) {
516 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
517 ro = 1;
518 } else {
7bc5c414
AD
519 if (sdp->sd_vfs->s_flags & MS_RDONLY) {
520 /* check if device itself is read-only */
521 ro = bdev_read_only(sdp->sd_vfs->s_bdev);
522 if (!ro) {
523 fs_info(sdp, "recovery required on "
524 "read-only filesystem.\n");
525 fs_info(sdp, "write access will be "
526 "enabled during recovery.\n");
527 }
528 }
b3b94faa
DT
529 }
530
531 if (ro) {
7bc5c414
AD
532 fs_warn(sdp, "jid=%u: Can't replay: read-only block "
533 "device\n", jd->jd_jid);
b3b94faa
DT
534 error = -EROFS;
535 goto fail_gunlock_tr;
536 }
537
538 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
539
540 for (pass = 0; pass < 2; pass++) {
541 lops_before_scan(jd, &head, pass);
542 error = foreach_descriptor(jd, head.lh_tail,
543 head.lh_blkno, pass);
544 lops_after_scan(jd, error, pass);
545 if (error)
546 goto fail_gunlock_tr;
547 }
548
549 error = clean_journal(jd, &head);
550 if (error)
551 goto fail_gunlock_tr;
552
553 gfs2_glock_dq_uninit(&t_gh);
5c676f6d 554 t = DIV_ROUND_UP(jiffies - t, HZ);
b3b94faa
DT
555 fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
556 jd->jd_jid, t);
557 }
558
5965b1f4
SW
559 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
560 gfs2_glock_dq_uninit(&ji_gh);
b3b94faa
DT
561
562 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
563
5965b1f4
SW
564 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
565 gfs2_glock_dq_uninit(&j_gh);
b3b94faa
DT
566
567 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
b3b94faa
DT
568 return 0;
569
5965b1f4 570fail_gunlock_tr:
b3b94faa 571 gfs2_glock_dq_uninit(&t_gh);
5965b1f4
SW
572fail_gunlock_ji:
573 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
574 gfs2_glock_dq_uninit(&ji_gh);
575fail_gunlock_j:
576 gfs2_glock_dq_uninit(&j_gh);
577 }
b3b94faa
DT
578
579 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
580
5965b1f4 581fail:
b3b94faa 582 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
b3b94faa
DT
583 return error;
584}
585
586/**
587 * gfs2_check_journals - Recover any dirty journals
588 * @sdp: the filesystem
589 *
590 */
591
592void gfs2_check_journals(struct gfs2_sbd *sdp)
593{
594 struct gfs2_jdesc *jd;
595
596 for (;;) {
597 jd = gfs2_jdesc_find_dirty(sdp);
598 if (!jd)
599 break;
600
601 if (jd != sdp->sd_jdesc)
c63e31c2 602 gfs2_recover_journal(jd);
b3b94faa
DT
603 }
604}
605