]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/gfs2/recovery.c
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2.
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/gfs2_ondisk.h>
16 #include <linux/crc32.h>
19 #include "lm_interface.h"
32 int gfs2_replay_read_block(struct gfs2_jdesc
*jd
, unsigned int blk
,
33 struct buffer_head
**bh
)
35 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
36 struct gfs2_glock
*gl
= ip
->i_gl
;
42 error
= gfs2_extent_map(&ip
->i_inode
, blk
, &new, &dblock
, &extlen
);
46 gfs2_consist_inode(ip
);
50 gfs2_meta_ra(gl
, dblock
, extlen
);
51 error
= gfs2_meta_read(gl
, dblock
, DIO_START
| DIO_WAIT
, bh
);
56 int gfs2_revoke_add(struct gfs2_sbd
*sdp
, u64 blkno
, unsigned int where
)
58 struct list_head
*head
= &sdp
->sd_revoke_list
;
59 struct gfs2_revoke_replay
*rr
;
62 list_for_each_entry(rr
, head
, rr_list
) {
63 if (rr
->rr_blkno
== blkno
) {
74 rr
= kmalloc(sizeof(struct gfs2_revoke_replay
), GFP_KERNEL
);
80 list_add(&rr
->rr_list
, head
);
85 int gfs2_revoke_check(struct gfs2_sbd
*sdp
, u64 blkno
, unsigned int where
)
87 struct gfs2_revoke_replay
*rr
;
88 int wrap
, a
, b
, revoke
;
91 list_for_each_entry(rr
, &sdp
->sd_revoke_list
, rr_list
) {
92 if (rr
->rr_blkno
== blkno
) {
101 wrap
= (rr
->rr_where
< sdp
->sd_replay_tail
);
102 a
= (sdp
->sd_replay_tail
< where
);
103 b
= (where
< rr
->rr_where
);
104 revoke
= (wrap
) ? (a
|| b
) : (a
&& b
);
109 void gfs2_revoke_clean(struct gfs2_sbd
*sdp
)
111 struct list_head
*head
= &sdp
->sd_revoke_list
;
112 struct gfs2_revoke_replay
*rr
;
114 while (!list_empty(head
)) {
115 rr
= list_entry(head
->next
, struct gfs2_revoke_replay
, rr_list
);
116 list_del(&rr
->rr_list
);
122 * get_log_header - read the log header for a given segment
124 * @blk: the block to look at
125 * @lh: the log header to return
127 * Read the log header for a given segement in a given journal. Do a few
128 * sanity checks on it.
130 * Returns: 0 on success,
131 * 1 if the header was invalid or incomplete,
135 static int get_log_header(struct gfs2_jdesc
*jd
, unsigned int blk
,
136 struct gfs2_log_header
*head
)
138 struct buffer_head
*bh
;
139 struct gfs2_log_header lh
;
143 error
= gfs2_replay_read_block(jd
, blk
, &bh
);
147 memcpy(&lh
, bh
->b_data
, sizeof(struct gfs2_log_header
));
149 hash
= gfs2_disk_hash((char *)&lh
, sizeof(struct gfs2_log_header
));
150 gfs2_log_header_in(&lh
, bh
->b_data
);
154 if (lh
.lh_header
.mh_magic
!= GFS2_MAGIC
||
155 lh
.lh_header
.mh_type
!= GFS2_METATYPE_LH
||
156 lh
.lh_blkno
!= blk
|| lh
.lh_hash
!= hash
)
165 * find_good_lh - find a good log header
167 * @blk: the segment to start searching from
168 * @lh: the log header to fill in
169 * @forward: if true search forward in the log, else search backward
171 * Call get_log_header() to get a log header for a segment, but if the
172 * segment is bad, either scan forward or backward until we find a good one.
177 static int find_good_lh(struct gfs2_jdesc
*jd
, unsigned int *blk
,
178 struct gfs2_log_header
*head
)
180 unsigned int orig_blk
= *blk
;
184 error
= get_log_header(jd
, *blk
, head
);
188 if (++*blk
== jd
->jd_blocks
)
191 if (*blk
== orig_blk
) {
192 gfs2_consist_inode(GFS2_I(jd
->jd_inode
));
199 * jhead_scan - make sure we've found the head of the log
201 * @head: this is filled in with the log descriptor of the head
203 * At this point, seg and lh should be either the head of the log or just
204 * before. Scan forward until we find the head.
209 static int jhead_scan(struct gfs2_jdesc
*jd
, struct gfs2_log_header
*head
)
211 unsigned int blk
= head
->lh_blkno
;
212 struct gfs2_log_header lh
;
216 if (++blk
== jd
->jd_blocks
)
219 error
= get_log_header(jd
, blk
, &lh
);
225 if (lh
.lh_sequence
== head
->lh_sequence
) {
226 gfs2_consist_inode(GFS2_I(jd
->jd_inode
));
229 if (lh
.lh_sequence
< head
->lh_sequence
)
239 * gfs2_find_jhead - find the head of a log
241 * @head: the log descriptor for the head of the log is returned here
243 * Do a binary search of a journal and find the valid log entry with the
244 * highest sequence number. (i.e. the log head)
249 int gfs2_find_jhead(struct gfs2_jdesc
*jd
, struct gfs2_log_header
*head
)
251 struct gfs2_log_header lh_1
, lh_m
;
252 u32 blk_1
, blk_2
, blk_m
;
256 blk_2
= jd
->jd_blocks
- 1;
259 blk_m
= (blk_1
+ blk_2
) / 2;
261 error
= find_good_lh(jd
, &blk_1
, &lh_1
);
265 error
= find_good_lh(jd
, &blk_m
, &lh_m
);
269 if (blk_1
== blk_m
|| blk_m
== blk_2
)
272 if (lh_1
.lh_sequence
<= lh_m
.lh_sequence
)
278 error
= jhead_scan(jd
, &lh_1
);
288 * foreach_descriptor - go through the active part of the log
290 * @start: the first log header in the active region
291 * @end: the last log header (don't process the contents of this entry))
293 * Call a given function once for every log descriptor in the active
294 * portion of the log.
299 static int foreach_descriptor(struct gfs2_jdesc
*jd
, unsigned int start
,
300 unsigned int end
, int pass
)
302 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
303 struct buffer_head
*bh
;
304 struct gfs2_log_descriptor
*ld
;
308 unsigned int offset
= sizeof(struct gfs2_log_descriptor
);
309 offset
+= (sizeof(__be64
)-1);
310 offset
&= ~(sizeof(__be64
)-1);
312 while (start
!= end
) {
313 error
= gfs2_replay_read_block(jd
, start
, &bh
);
316 if (gfs2_meta_check(sdp
, bh
)) {
320 ld
= (struct gfs2_log_descriptor
*)bh
->b_data
;
321 length
= be32_to_cpu(ld
->ld_length
);
323 if (be32_to_cpu(ld
->ld_header
.mh_type
) == GFS2_METATYPE_LH
) {
324 struct gfs2_log_header lh
;
325 error
= get_log_header(jd
, start
, &lh
);
327 gfs2_replay_incr_blk(sdp
, &start
);
332 gfs2_consist_inode(GFS2_I(jd
->jd_inode
));
337 } else if (gfs2_metatype_check(sdp
, bh
, GFS2_METATYPE_LD
)) {
341 ptr
= (__be64
*)(bh
->b_data
+ offset
);
342 error
= lops_scan_elements(jd
, start
, ld
, ptr
, pass
);
349 gfs2_replay_incr_blk(sdp
, &start
);
358 * clean_journal - mark a dirty journal as being clean
359 * @sdp: the filesystem
361 * @gl: the journal's glock
362 * @head: the head journal to start from
367 static int clean_journal(struct gfs2_jdesc
*jd
, struct gfs2_log_header
*head
)
369 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
370 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
374 struct gfs2_log_header
*lh
;
376 struct buffer_head
*bh
;
380 lblock
= head
->lh_blkno
;
381 gfs2_replay_incr_blk(sdp
, &lblock
);
382 error
= gfs2_block_map(&ip
->i_inode
, lblock
, &new, &dblock
, &boundary
);
386 gfs2_consist_inode(ip
);
390 bh
= sb_getblk(sdp
->sd_vfs
, dblock
);
392 memset(bh
->b_data
, 0, bh
->b_size
);
393 set_buffer_uptodate(bh
);
394 clear_buffer_dirty(bh
);
397 lh
= (struct gfs2_log_header
*)bh
->b_data
;
398 memset(lh
, 0, sizeof(struct gfs2_log_header
));
399 lh
->lh_header
.mh_magic
= cpu_to_be32(GFS2_MAGIC
);
400 lh
->lh_header
.mh_type
= cpu_to_be32(GFS2_METATYPE_LH
);
401 lh
->lh_header
.mh_format
= cpu_to_be32(GFS2_FORMAT_LH
);
402 lh
->lh_sequence
= cpu_to_be64(head
->lh_sequence
+ 1);
403 lh
->lh_flags
= cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT
);
404 lh
->lh_blkno
= cpu_to_be32(lblock
);
405 hash
= gfs2_disk_hash((const char *)lh
, sizeof(struct gfs2_log_header
));
406 lh
->lh_hash
= cpu_to_be32(hash
);
408 set_buffer_dirty(bh
);
409 if (sync_dirty_buffer(bh
))
410 gfs2_io_error_bh(sdp
, bh
);
417 * gfs2_recover_journal - recovery a given journal
418 * @jd: the struct gfs2_jdesc describing the journal
420 * Acquire the journal's lock, check to see if the journal is clean, and
421 * do recovery if necessary.
426 int gfs2_recover_journal(struct gfs2_jdesc
*jd
)
428 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
429 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
430 struct gfs2_log_header head
;
431 struct gfs2_holder j_gh
, ji_gh
, t_gh
;
437 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
) {
438 fs_info(sdp
, "jid=%u: Trying to acquire journal lock...\n",
441 /* Aquire the journal lock so we can do recovery */
443 error
= gfs2_glock_nq_num(sdp
, jd
->jd_jid
, &gfs2_journal_glops
,
445 LM_FLAG_NOEXP
| LM_FLAG_TRY
| GL_NOCACHE
,
452 fs_info(sdp
, "jid=%u: Busy\n", jd
->jd_jid
);
459 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
,
460 LM_FLAG_NOEXP
, &ji_gh
);
464 fs_info(sdp
, "jid=%u, already locked for use\n", jd
->jd_jid
);
467 fs_info(sdp
, "jid=%u: Looking at journal...\n", jd
->jd_jid
);
469 error
= gfs2_jdesc_check(jd
);
471 goto fail_gunlock_ji
;
473 error
= gfs2_find_jhead(jd
, &head
);
475 goto fail_gunlock_ji
;
477 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
478 fs_info(sdp
, "jid=%u: Acquiring the transaction lock...\n",
483 /* Acquire a shared hold on the transaction lock */
485 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_SHARED
,
486 LM_FLAG_NOEXP
| LM_FLAG_PRIORITY
|
487 GL_NOCANCEL
| GL_NOCACHE
, &t_gh
);
489 goto fail_gunlock_ji
;
491 if (test_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
)) {
492 if (!test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
))
495 if (sdp
->sd_vfs
->s_flags
& MS_RDONLY
)
500 fs_warn(sdp
, "jid=%u: Can't replay: read-only FS\n",
503 goto fail_gunlock_tr
;
506 fs_info(sdp
, "jid=%u: Replaying journal...\n", jd
->jd_jid
);
508 for (pass
= 0; pass
< 2; pass
++) {
509 lops_before_scan(jd
, &head
, pass
);
510 error
= foreach_descriptor(jd
, head
.lh_tail
,
511 head
.lh_blkno
, pass
);
512 lops_after_scan(jd
, error
, pass
);
514 goto fail_gunlock_tr
;
517 error
= clean_journal(jd
, &head
);
519 goto fail_gunlock_tr
;
521 gfs2_glock_dq_uninit(&t_gh
);
522 t
= DIV_ROUND_UP(jiffies
- t
, HZ
);
523 fs_info(sdp
, "jid=%u: Journal replayed in %lus\n",
527 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
)
528 gfs2_glock_dq_uninit(&ji_gh
);
530 gfs2_lm_recovery_done(sdp
, jd
->jd_jid
, LM_RD_SUCCESS
);
532 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
)
533 gfs2_glock_dq_uninit(&j_gh
);
535 fs_info(sdp
, "jid=%u: Done\n", jd
->jd_jid
);
539 gfs2_glock_dq_uninit(&t_gh
);
541 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
) {
542 gfs2_glock_dq_uninit(&ji_gh
);
544 gfs2_glock_dq_uninit(&j_gh
);
547 fs_info(sdp
, "jid=%u: %s\n", jd
->jd_jid
, (error
) ? "Failed" : "Done");
550 gfs2_lm_recovery_done(sdp
, jd
->jd_jid
, LM_RD_GAVEUP
);
555 * gfs2_check_journals - Recover any dirty journals
556 * @sdp: the filesystem
560 void gfs2_check_journals(struct gfs2_sbd
*sdp
)
562 struct gfs2_jdesc
*jd
;
565 jd
= gfs2_jdesc_find_dirty(sdp
);
569 if (jd
!= sdp
->sd_jdesc
)
570 gfs2_recover_journal(jd
);