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/module.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>
17 #include <linux/crc32c.h>
18 #include <linux/ktime.h>
33 struct workqueue_struct
*gfs_recovery_wq
;
35 int gfs2_replay_read_block(struct gfs2_jdesc
*jd
, unsigned int blk
,
36 struct buffer_head
**bh
)
38 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
39 struct gfs2_glock
*gl
= ip
->i_gl
;
45 error
= gfs2_extent_map(&ip
->i_inode
, blk
, &new, &dblock
, &extlen
);
49 gfs2_consist_inode(ip
);
53 *bh
= gfs2_meta_ra(gl
, dblock
, extlen
);
58 int gfs2_revoke_add(struct gfs2_jdesc
*jd
, u64 blkno
, unsigned int where
)
60 struct list_head
*head
= &jd
->jd_revoke_list
;
61 struct gfs2_revoke_replay
*rr
;
64 list_for_each_entry(rr
, head
, rr_list
) {
65 if (rr
->rr_blkno
== blkno
) {
76 rr
= kmalloc(sizeof(struct gfs2_revoke_replay
), GFP_NOFS
);
82 list_add(&rr
->rr_list
, head
);
87 int gfs2_revoke_check(struct gfs2_jdesc
*jd
, u64 blkno
, unsigned int where
)
89 struct gfs2_revoke_replay
*rr
;
90 int wrap
, a
, b
, revoke
;
93 list_for_each_entry(rr
, &jd
->jd_revoke_list
, rr_list
) {
94 if (rr
->rr_blkno
== blkno
) {
103 wrap
= (rr
->rr_where
< jd
->jd_replay_tail
);
104 a
= (jd
->jd_replay_tail
< where
);
105 b
= (where
< rr
->rr_where
);
106 revoke
= (wrap
) ? (a
|| b
) : (a
&& b
);
111 void gfs2_revoke_clean(struct gfs2_jdesc
*jd
)
113 struct list_head
*head
= &jd
->jd_revoke_list
;
114 struct gfs2_revoke_replay
*rr
;
116 while (!list_empty(head
)) {
117 rr
= list_entry(head
->next
, struct gfs2_revoke_replay
, rr_list
);
118 list_del(&rr
->rr_list
);
123 int __get_log_header(struct gfs2_sbd
*sdp
, const struct gfs2_log_header
*lh
,
124 unsigned int blkno
, struct gfs2_log_header_host
*head
)
128 if (lh
->lh_header
.mh_magic
!= cpu_to_be32(GFS2_MAGIC
) ||
129 lh
->lh_header
.mh_type
!= cpu_to_be32(GFS2_METATYPE_LH
) ||
130 (blkno
&& be32_to_cpu(lh
->lh_blkno
) != blkno
))
133 hash
= crc32(~0, lh
, LH_V1_SIZE
- 4);
134 hash
= ~crc32_le_shift(hash
, 4); /* assume lh_hash is zero */
136 if (be32_to_cpu(lh
->lh_hash
) != hash
)
139 crc
= crc32c(~0, (void *)lh
+ LH_V1_SIZE
+ 4,
140 sdp
->sd_sb
.sb_bsize
- LH_V1_SIZE
- 4);
142 if ((lh
->lh_crc
!= 0 && be32_to_cpu(lh
->lh_crc
) != crc
))
145 head
->lh_sequence
= be64_to_cpu(lh
->lh_sequence
);
146 head
->lh_flags
= be32_to_cpu(lh
->lh_flags
);
147 head
->lh_tail
= be32_to_cpu(lh
->lh_tail
);
148 head
->lh_blkno
= be32_to_cpu(lh
->lh_blkno
);
153 * get_log_header - read the log header for a given segment
155 * @blk: the block to look at
156 * @lh: the log header to return
158 * Read the log header for a given segement in a given journal. Do a few
159 * sanity checks on it.
161 * Returns: 0 on success,
162 * 1 if the header was invalid or incomplete,
166 static int get_log_header(struct gfs2_jdesc
*jd
, unsigned int blk
,
167 struct gfs2_log_header_host
*head
)
169 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
170 struct buffer_head
*bh
;
173 error
= gfs2_replay_read_block(jd
, blk
, &bh
);
177 error
= __get_log_header(sdp
, (const struct gfs2_log_header
*)bh
->b_data
,
185 * find_good_lh - find a good log header
187 * @blk: the segment to start searching from
188 * @lh: the log header to fill in
189 * @forward: if true search forward in the log, else search backward
191 * Call get_log_header() to get a log header for a segment, but if the
192 * segment is bad, either scan forward or backward until we find a good one.
197 static int find_good_lh(struct gfs2_jdesc
*jd
, unsigned int *blk
,
198 struct gfs2_log_header_host
*head
)
200 unsigned int orig_blk
= *blk
;
204 error
= get_log_header(jd
, *blk
, head
);
208 if (++*blk
== jd
->jd_blocks
)
211 if (*blk
== orig_blk
) {
212 gfs2_consist_inode(GFS2_I(jd
->jd_inode
));
219 * jhead_scan - make sure we've found the head of the log
221 * @head: this is filled in with the log descriptor of the head
223 * At this point, seg and lh should be either the head of the log or just
224 * before. Scan forward until we find the head.
229 static int jhead_scan(struct gfs2_jdesc
*jd
, struct gfs2_log_header_host
*head
)
231 unsigned int blk
= head
->lh_blkno
;
232 struct gfs2_log_header_host lh
;
236 if (++blk
== jd
->jd_blocks
)
239 error
= get_log_header(jd
, blk
, &lh
);
245 if (lh
.lh_sequence
== head
->lh_sequence
) {
246 gfs2_consist_inode(GFS2_I(jd
->jd_inode
));
249 if (lh
.lh_sequence
< head
->lh_sequence
)
259 * gfs2_find_jhead - find the head of a log
261 * @head: the log descriptor for the head of the log is returned here
263 * Do a binary search of a journal and find the valid log entry with the
264 * highest sequence number. (i.e. the log head)
269 int gfs2_find_jhead(struct gfs2_jdesc
*jd
, struct gfs2_log_header_host
*head
)
271 struct gfs2_log_header_host lh_1
, lh_m
;
272 u32 blk_1
, blk_2
, blk_m
;
276 blk_2
= jd
->jd_blocks
- 1;
279 blk_m
= (blk_1
+ blk_2
) / 2;
281 error
= find_good_lh(jd
, &blk_1
, &lh_1
);
285 error
= find_good_lh(jd
, &blk_m
, &lh_m
);
289 if (blk_1
== blk_m
|| blk_m
== blk_2
)
292 if (lh_1
.lh_sequence
<= lh_m
.lh_sequence
)
298 error
= jhead_scan(jd
, &lh_1
);
308 * foreach_descriptor - go through the active part of the log
310 * @start: the first log header in the active region
311 * @end: the last log header (don't process the contents of this entry))
313 * Call a given function once for every log descriptor in the active
314 * portion of the log.
319 static int foreach_descriptor(struct gfs2_jdesc
*jd
, unsigned int start
,
320 unsigned int end
, int pass
)
322 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
323 struct buffer_head
*bh
;
324 struct gfs2_log_descriptor
*ld
;
328 unsigned int offset
= sizeof(struct gfs2_log_descriptor
);
329 offset
+= sizeof(__be64
) - 1;
330 offset
&= ~(sizeof(__be64
) - 1);
332 while (start
!= end
) {
333 error
= gfs2_replay_read_block(jd
, start
, &bh
);
336 if (gfs2_meta_check(sdp
, bh
)) {
340 ld
= (struct gfs2_log_descriptor
*)bh
->b_data
;
341 length
= be32_to_cpu(ld
->ld_length
);
343 if (be32_to_cpu(ld
->ld_header
.mh_type
) == GFS2_METATYPE_LH
) {
344 struct gfs2_log_header_host lh
;
345 error
= get_log_header(jd
, start
, &lh
);
347 gfs2_replay_incr_blk(jd
, &start
);
352 gfs2_consist_inode(GFS2_I(jd
->jd_inode
));
357 } else if (gfs2_metatype_check(sdp
, bh
, GFS2_METATYPE_LD
)) {
361 ptr
= (__be64
*)(bh
->b_data
+ offset
);
362 error
= lops_scan_elements(jd
, start
, ld
, ptr
, pass
);
369 gfs2_replay_incr_blk(jd
, &start
);
378 * clean_journal - mark a dirty journal as being clean
380 * @head: the head journal to start from
385 static void clean_journal(struct gfs2_jdesc
*jd
,
386 struct gfs2_log_header_host
*head
)
388 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
390 sdp
->sd_log_flush_head
= head
->lh_blkno
;
391 gfs2_replay_incr_blk(jd
, &sdp
->sd_log_flush_head
);
392 gfs2_write_log_header(sdp
, jd
, head
->lh_sequence
+ 1, 0,
393 GFS2_LOG_HEAD_UNMOUNT
| GFS2_LOG_HEAD_RECOVERY
,
394 REQ_PREFLUSH
| REQ_FUA
| REQ_META
| REQ_SYNC
);
398 static void gfs2_recovery_done(struct gfs2_sbd
*sdp
, unsigned int jid
,
399 unsigned int message
)
403 char *envp
[] = { env_jid
, env_status
, NULL
};
404 struct lm_lockstruct
*ls
= &sdp
->sd_lockstruct
;
406 ls
->ls_recover_jid_done
= jid
;
407 ls
->ls_recover_jid_status
= message
;
408 sprintf(env_jid
, "JID=%u", jid
);
409 sprintf(env_status
, "RECOVERY=%s",
410 message
== LM_RD_SUCCESS
? "Done" : "Failed");
411 kobject_uevent_env(&sdp
->sd_kobj
, KOBJ_CHANGE
, envp
);
413 if (sdp
->sd_lockstruct
.ls_ops
->lm_recovery_result
)
414 sdp
->sd_lockstruct
.ls_ops
->lm_recovery_result(sdp
, jid
, message
);
417 void gfs2_recover_func(struct work_struct
*work
)
419 struct gfs2_jdesc
*jd
= container_of(work
, struct gfs2_jdesc
, jd_work
);
420 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
421 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
422 struct gfs2_log_header_host head
;
423 struct gfs2_holder j_gh
, ji_gh
, thaw_gh
;
424 ktime_t t_start
, t_jlck
, t_jhd
, t_tlck
, t_rep
;
430 t_start
= ktime_get();
431 if (sdp
->sd_args
.ar_spectator
)
433 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
) {
434 fs_info(sdp
, "jid=%u: Trying to acquire journal lock...\n",
437 /* Acquire the journal lock so we can do recovery */
439 error
= gfs2_glock_nq_num(sdp
, jd
->jd_jid
, &gfs2_journal_glops
,
441 LM_FLAG_NOEXP
| LM_FLAG_TRY
| GL_NOCACHE
,
448 fs_info(sdp
, "jid=%u: Busy\n", jd
->jd_jid
);
455 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
,
456 LM_FLAG_NOEXP
| GL_NOCACHE
, &ji_gh
);
460 fs_info(sdp
, "jid=%u, already locked for use\n", jd
->jd_jid
);
463 t_jlck
= ktime_get();
464 fs_info(sdp
, "jid=%u: Looking at journal...\n", jd
->jd_jid
);
466 error
= gfs2_jdesc_check(jd
);
468 goto fail_gunlock_ji
;
470 error
= gfs2_find_jhead(jd
, &head
);
472 goto fail_gunlock_ji
;
474 fs_info(sdp
, "jid=%u: Journal head lookup took %lldms\n", jd
->jd_jid
,
475 ktime_ms_delta(t_jhd
, t_jlck
));
477 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
478 fs_info(sdp
, "jid=%u: Acquiring the transaction lock...\n",
481 /* Acquire a shared hold on the freeze lock */
483 error
= gfs2_glock_nq_init(sdp
->sd_freeze_gl
, LM_ST_SHARED
,
484 LM_FLAG_NOEXP
| LM_FLAG_PRIORITY
,
487 goto fail_gunlock_ji
;
489 if (test_bit(SDF_RORECOVERY
, &sdp
->sd_flags
)) {
491 } else if (test_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
)) {
492 if (!test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
))
495 if (sb_rdonly(sdp
->sd_vfs
)) {
496 /* check if device itself is read-only */
497 ro
= bdev_read_only(sdp
->sd_vfs
->s_bdev
);
499 fs_info(sdp
, "recovery required on "
500 "read-only filesystem.\n");
501 fs_info(sdp
, "write access will be "
502 "enabled during recovery.\n");
508 fs_warn(sdp
, "jid=%u: Can't replay: read-only block "
509 "device\n", jd
->jd_jid
);
511 goto fail_gunlock_thaw
;
514 t_tlck
= ktime_get();
515 fs_info(sdp
, "jid=%u: Replaying journal...\n", jd
->jd_jid
);
517 for (pass
= 0; pass
< 2; pass
++) {
518 lops_before_scan(jd
, &head
, pass
);
519 error
= foreach_descriptor(jd
, head
.lh_tail
,
520 head
.lh_blkno
, pass
);
521 lops_after_scan(jd
, error
, pass
);
523 goto fail_gunlock_thaw
;
526 clean_journal(jd
, &head
);
528 gfs2_glock_dq_uninit(&thaw_gh
);
530 fs_info(sdp
, "jid=%u: Journal replayed in %lldms [jlck:%lldms, "
531 "jhead:%lldms, tlck:%lldms, replay:%lldms]\n",
532 jd
->jd_jid
, ktime_ms_delta(t_rep
, t_start
),
533 ktime_ms_delta(t_jlck
, t_start
),
534 ktime_ms_delta(t_jhd
, t_jlck
),
535 ktime_ms_delta(t_tlck
, t_jhd
),
536 ktime_ms_delta(t_rep
, t_tlck
));
539 gfs2_recovery_done(sdp
, jd
->jd_jid
, LM_RD_SUCCESS
);
542 gfs2_glock_dq_uninit(&ji_gh
);
543 gfs2_glock_dq_uninit(&j_gh
);
546 fs_info(sdp
, "jid=%u: Done\n", jd
->jd_jid
);
550 gfs2_glock_dq_uninit(&thaw_gh
);
553 gfs2_glock_dq_uninit(&ji_gh
);
555 gfs2_glock_dq_uninit(&j_gh
);
558 fs_info(sdp
, "jid=%u: %s\n", jd
->jd_jid
, (error
) ? "Failed" : "Done");
560 jd
->jd_recover_error
= error
;
561 gfs2_recovery_done(sdp
, jd
->jd_jid
, LM_RD_GAVEUP
);
563 clear_bit(JDF_RECOVERY
, &jd
->jd_flags
);
564 smp_mb__after_atomic();
565 wake_up_bit(&jd
->jd_flags
, JDF_RECOVERY
);
568 int gfs2_recover_journal(struct gfs2_jdesc
*jd
, bool wait
)
572 if (test_and_set_bit(JDF_RECOVERY
, &jd
->jd_flags
))
575 /* we have JDF_RECOVERY, queue should always succeed */
576 rv
= queue_work(gfs_recovery_wq
, &jd
->jd_work
);
580 wait_on_bit(&jd
->jd_flags
, JDF_RECOVERY
,
581 TASK_UNINTERRUPTIBLE
);
583 return wait
? jd
->jd_recover_error
: 0;