]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/gfs2/recovery.c
e5f2b284fa54ebd7ac0387102e51678b0bbaf5ad
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2005 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 v.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 <asm/semaphore.h>
27 int gfs2_replay_read_block(struct gfs2_jdesc
*jd
, unsigned int blk
,
28 struct buffer_head
**bh
)
30 struct gfs2_glock
*gl
= get_v2ip(jd
->jd_inode
)->i_gl
;
36 error
= gfs2_block_map(get_v2ip(jd
->jd_inode
), blk
, &new, &dblock
,
41 gfs2_consist_inode(get_v2ip(jd
->jd_inode
));
45 gfs2_meta_ra(gl
, dblock
, extlen
);
46 error
= gfs2_meta_read(gl
, dblock
, DIO_START
| DIO_WAIT
, bh
);
51 int gfs2_revoke_add(struct gfs2_sbd
*sdp
, uint64_t blkno
, unsigned int where
)
53 struct list_head
*head
= &sdp
->sd_revoke_list
;
54 struct gfs2_revoke_replay
*rr
;
57 list_for_each_entry(rr
, head
, rr_list
) {
58 if (rr
->rr_blkno
== blkno
) {
69 rr
= kmalloc(sizeof(struct gfs2_revoke_replay
), GFP_KERNEL
);
75 list_add(&rr
->rr_list
, head
);
80 int gfs2_revoke_check(struct gfs2_sbd
*sdp
, uint64_t blkno
, unsigned int where
)
82 struct gfs2_revoke_replay
*rr
;
83 int wrap
, a
, b
, revoke
;
86 list_for_each_entry(rr
, &sdp
->sd_revoke_list
, rr_list
) {
87 if (rr
->rr_blkno
== blkno
) {
96 wrap
= (rr
->rr_where
< sdp
->sd_replay_tail
);
97 a
= (sdp
->sd_replay_tail
< where
);
98 b
= (where
< rr
->rr_where
);
99 revoke
= (wrap
) ? (a
|| b
) : (a
&& b
);
104 void gfs2_revoke_clean(struct gfs2_sbd
*sdp
)
106 struct list_head
*head
= &sdp
->sd_revoke_list
;
107 struct gfs2_revoke_replay
*rr
;
109 while (!list_empty(head
)) {
110 rr
= list_entry(head
->next
, struct gfs2_revoke_replay
, rr_list
);
111 list_del(&rr
->rr_list
);
117 * get_log_header - read the log header for a given segment
119 * @blk: the block to look at
120 * @lh: the log header to return
122 * Read the log header for a given segement in a given journal. Do a few
123 * sanity checks on it.
125 * Returns: 0 on success,
126 * 1 if the header was invalid or incomplete,
130 static int get_log_header(struct gfs2_jdesc
*jd
, unsigned int blk
,
131 struct gfs2_log_header
*head
)
133 struct buffer_head
*bh
;
134 struct gfs2_log_header lh
;
138 error
= gfs2_replay_read_block(jd
, blk
, &bh
);
142 memcpy(&lh
, bh
->b_data
, sizeof(struct gfs2_log_header
));
144 hash
= gfs2_disk_hash((char *)&lh
, sizeof(struct gfs2_log_header
));
145 gfs2_log_header_in(&lh
, bh
->b_data
);
149 if (lh
.lh_header
.mh_magic
!= GFS2_MAGIC
||
150 lh
.lh_header
.mh_type
!= GFS2_METATYPE_LH
||
151 lh
.lh_blkno
!= blk
||
161 * find_good_lh - find a good log header
163 * @blk: the segment to start searching from
164 * @lh: the log header to fill in
165 * @forward: if true search forward in the log, else search backward
167 * Call get_log_header() to get a log header for a segment, but if the
168 * segment is bad, either scan forward or backward until we find a good one.
173 static int find_good_lh(struct gfs2_jdesc
*jd
, unsigned int *blk
,
174 struct gfs2_log_header
*head
)
176 unsigned int orig_blk
= *blk
;
180 error
= get_log_header(jd
, *blk
, head
);
184 if (++*blk
== jd
->jd_blocks
)
187 if (*blk
== orig_blk
) {
188 gfs2_consist_inode(get_v2ip(jd
->jd_inode
));
195 * jhead_scan - make sure we've found the head of the log
197 * @head: this is filled in with the log descriptor of the head
199 * At this point, seg and lh should be either the head of the log or just
200 * before. Scan forward until we find the head.
205 static int jhead_scan(struct gfs2_jdesc
*jd
, struct gfs2_log_header
*head
)
207 unsigned int blk
= head
->lh_blkno
;
208 struct gfs2_log_header lh
;
212 if (++blk
== jd
->jd_blocks
)
215 error
= get_log_header(jd
, blk
, &lh
);
221 if (lh
.lh_sequence
== head
->lh_sequence
) {
222 gfs2_consist_inode(get_v2ip(jd
->jd_inode
));
225 if (lh
.lh_sequence
< head
->lh_sequence
)
235 * gfs2_find_jhead - find the head of a log
237 * @head: the log descriptor for the head of the log is returned here
239 * Do a binary search of a journal and find the valid log entry with the
240 * highest sequence number. (i.e. the log head)
245 int gfs2_find_jhead(struct gfs2_jdesc
*jd
, struct gfs2_log_header
*head
)
247 struct gfs2_log_header lh_1
, lh_m
;
248 uint32_t blk_1
, blk_2
, blk_m
;
252 blk_2
= jd
->jd_blocks
- 1;
255 blk_m
= (blk_1
+ blk_2
) / 2;
257 error
= find_good_lh(jd
, &blk_1
, &lh_1
);
261 error
= find_good_lh(jd
, &blk_m
, &lh_m
);
265 if (blk_1
== blk_m
|| blk_m
== blk_2
)
268 if (lh_1
.lh_sequence
<= lh_m
.lh_sequence
)
274 error
= jhead_scan(jd
, &lh_1
);
284 * foreach_descriptor - go through the active part of the log
286 * @start: the first log header in the active region
287 * @end: the last log header (don't process the contents of this entry))
289 * Call a given function once for every log descriptor in the active
290 * portion of the log.
295 static int foreach_descriptor(struct gfs2_jdesc
*jd
, unsigned int start
,
296 unsigned int end
, int pass
)
298 struct gfs2_sbd
*sdp
= get_v2ip(jd
->jd_inode
)->i_sbd
;
299 struct buffer_head
*bh
;
300 struct gfs2_log_descriptor
*ld
;
304 unsigned int offset
= sizeof(struct gfs2_log_descriptor
);
305 offset
+= (sizeof(__be64
)-1);
306 offset
&= ~(sizeof(__be64
)-1);
308 while (start
!= end
) {
309 error
= gfs2_replay_read_block(jd
, start
, &bh
);
312 if (gfs2_meta_check(sdp
, bh
)) {
316 ld
= (struct gfs2_log_descriptor
*)bh
->b_data
;
317 length
= be32_to_cpu(ld
->ld_length
);
319 if (be16_to_cpu(ld
->ld_header
.mh_type
) == GFS2_METATYPE_LH
) {
320 struct gfs2_log_header lh
;
321 error
= get_log_header(jd
, start
, &lh
);
323 gfs2_replay_incr_blk(sdp
, &start
);
327 gfs2_consist_inode(get_v2ip(jd
->jd_inode
));
332 } else if (gfs2_metatype_check(sdp
, bh
, GFS2_METATYPE_LD
)) {
336 ptr
= (__be64
*)(bh
->b_data
+ offset
);
337 error
= lops_scan_elements(jd
, start
, ld
, ptr
, pass
);
344 gfs2_replay_incr_blk(sdp
, &start
);
353 * clean_journal - mark a dirty journal as being clean
354 * @sdp: the filesystem
356 * @gl: the journal's glock
357 * @head: the head journal to start from
362 static int clean_journal(struct gfs2_jdesc
*jd
, struct gfs2_log_header
*head
)
364 struct gfs2_inode
*ip
= get_v2ip(jd
->jd_inode
);
365 struct gfs2_sbd
*sdp
= ip
->i_sbd
;
369 struct gfs2_log_header
*lh
;
371 struct buffer_head
*bh
;
374 lblock
= head
->lh_blkno
;
375 gfs2_replay_incr_blk(sdp
, &lblock
);
376 error
= gfs2_block_map(ip
, lblock
, &new, &dblock
, NULL
);
380 gfs2_consist_inode(ip
);
384 bh
= sb_getblk(sdp
->sd_vfs
, dblock
);
386 memset(bh
->b_data
, 0, bh
->b_size
);
387 set_buffer_uptodate(bh
);
388 clear_buffer_dirty(bh
);
391 lh
= (struct gfs2_log_header
*)bh
->b_data
;
392 memset(lh
, 0, sizeof(struct gfs2_log_header
));
393 lh
->lh_header
.mh_magic
= cpu_to_be32(GFS2_MAGIC
);
394 lh
->lh_header
.mh_type
= cpu_to_be16(GFS2_METATYPE_LH
);
395 lh
->lh_header
.mh_format
= cpu_to_be16(GFS2_FORMAT_LH
);
396 lh
->lh_sequence
= cpu_to_be64(head
->lh_sequence
+ 1);
397 lh
->lh_flags
= cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT
);
398 lh
->lh_blkno
= cpu_to_be32(lblock
);
399 hash
= gfs2_disk_hash((const char *)lh
, sizeof(struct gfs2_log_header
));
400 lh
->lh_hash
= cpu_to_be32(hash
);
402 set_buffer_dirty(bh
);
403 if (sync_dirty_buffer(bh
))
404 gfs2_io_error_bh(sdp
, bh
);
411 * gfs2_recover_journal - recovery a given journal
412 * @jd: the struct gfs2_jdesc describing the journal
413 * @wait: Don't return until the journal is clean (or an error is encountered)
415 * Acquire the journal's lock, check to see if the journal is clean, and
416 * do recovery if necessary.
421 int gfs2_recover_journal(struct gfs2_jdesc
*jd
, int wait
)
423 struct gfs2_sbd
*sdp
= get_v2ip(jd
->jd_inode
)->i_sbd
;
424 struct gfs2_log_header head
;
425 struct gfs2_holder j_gh
, ji_gh
, t_gh
;
431 fs_info(sdp
, "jid=%u: Trying to acquire journal lock...\n", jd
->jd_jid
);
433 /* Aquire the journal lock so we can do recovery */
435 error
= gfs2_glock_nq_num(sdp
,
436 jd
->jd_jid
, &gfs2_journal_glops
,
439 ((wait
) ? 0 : LM_FLAG_TRY
) |
446 fs_info(sdp
, "jid=%u: Busy\n", jd
->jd_jid
);
453 error
= gfs2_glock_nq_init(get_v2ip(jd
->jd_inode
)->i_gl
, LM_ST_SHARED
,
454 LM_FLAG_NOEXP
, &ji_gh
);
458 fs_info(sdp
, "jid=%u: Looking at journal...\n", jd
->jd_jid
);
460 error
= gfs2_jdesc_check(jd
);
462 goto fail_gunlock_ji
;
464 error
= gfs2_find_jhead(jd
, &head
);
466 goto fail_gunlock_ji
;
468 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
469 fs_info(sdp
, "jid=%u: Acquiring the transaction lock...\n",
474 /* Acquire a shared hold on the transaction lock */
476 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
,
485 goto fail_gunlock_ji
;
487 if (test_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
)) {
488 if (!test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
))
491 if (sdp
->sd_vfs
->s_flags
& MS_RDONLY
)
496 fs_warn(sdp
, "jid=%u: Can't replay: read-only FS\n",
499 goto fail_gunlock_tr
;
502 fs_info(sdp
, "jid=%u: Replaying journal...\n", jd
->jd_jid
);
504 for (pass
= 0; pass
< 2; pass
++) {
505 lops_before_scan(jd
, &head
, pass
);
506 error
= foreach_descriptor(jd
, head
.lh_tail
,
507 head
.lh_blkno
, pass
);
508 lops_after_scan(jd
, error
, pass
);
510 goto fail_gunlock_tr
;
513 error
= clean_journal(jd
, &head
);
515 goto fail_gunlock_tr
;
517 gfs2_glock_dq_uninit(&t_gh
);
519 t
= DIV_RU(jiffies
- t
, HZ
);
521 fs_info(sdp
, "jid=%u: Journal replayed in %lus\n",
525 gfs2_glock_dq_uninit(&ji_gh
);
527 gfs2_lm_recovery_done(sdp
, jd
->jd_jid
, LM_RD_SUCCESS
);
529 gfs2_glock_dq_uninit(&j_gh
);
531 fs_info(sdp
, "jid=%u: Done\n", jd
->jd_jid
);
536 gfs2_glock_dq_uninit(&t_gh
);
539 gfs2_glock_dq_uninit(&ji_gh
);
542 gfs2_glock_dq_uninit(&j_gh
);
544 fs_info(sdp
, "jid=%u: %s\n", jd
->jd_jid
, (error
) ? "Failed" : "Done");
547 gfs2_lm_recovery_done(sdp
, jd
->jd_jid
, LM_RD_GAVEUP
);
553 * gfs2_check_journals - Recover any dirty journals
554 * @sdp: the filesystem
558 void gfs2_check_journals(struct gfs2_sbd
*sdp
)
560 struct gfs2_jdesc
*jd
;
563 jd
= gfs2_jdesc_find_dirty(sdp
);
567 if (jd
!= sdp
->sd_jdesc
)
568 gfs2_recover_journal(jd
, NO_WAIT
);