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 * foreach_descriptor - go through the active part of the log
187 * @start: the first log header in the active region
188 * @end: the last log header (don't process the contents of this entry))
190 * Call a given function once for every log descriptor in the active
191 * portion of the log.
196 static int foreach_descriptor(struct gfs2_jdesc
*jd
, unsigned int start
,
197 unsigned int end
, int pass
)
199 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
200 struct buffer_head
*bh
;
201 struct gfs2_log_descriptor
*ld
;
205 unsigned int offset
= sizeof(struct gfs2_log_descriptor
);
206 offset
+= sizeof(__be64
) - 1;
207 offset
&= ~(sizeof(__be64
) - 1);
209 while (start
!= end
) {
210 error
= gfs2_replay_read_block(jd
, start
, &bh
);
213 if (gfs2_meta_check(sdp
, bh
)) {
217 ld
= (struct gfs2_log_descriptor
*)bh
->b_data
;
218 length
= be32_to_cpu(ld
->ld_length
);
220 if (be32_to_cpu(ld
->ld_header
.mh_type
) == GFS2_METATYPE_LH
) {
221 struct gfs2_log_header_host lh
;
222 error
= get_log_header(jd
, start
, &lh
);
224 gfs2_replay_incr_blk(jd
, &start
);
229 gfs2_consist_inode(GFS2_I(jd
->jd_inode
));
234 } else if (gfs2_metatype_check(sdp
, bh
, GFS2_METATYPE_LD
)) {
238 ptr
= (__be64
*)(bh
->b_data
+ offset
);
239 error
= lops_scan_elements(jd
, start
, ld
, ptr
, pass
);
246 gfs2_replay_incr_blk(jd
, &start
);
255 * clean_journal - mark a dirty journal as being clean
257 * @head: the head journal to start from
262 static void clean_journal(struct gfs2_jdesc
*jd
,
263 struct gfs2_log_header_host
*head
)
265 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
267 sdp
->sd_log_flush_head
= head
->lh_blkno
;
268 gfs2_replay_incr_blk(jd
, &sdp
->sd_log_flush_head
);
269 gfs2_write_log_header(sdp
, jd
, head
->lh_sequence
+ 1, 0,
270 GFS2_LOG_HEAD_UNMOUNT
| GFS2_LOG_HEAD_RECOVERY
,
271 REQ_PREFLUSH
| REQ_FUA
| REQ_META
| REQ_SYNC
);
275 static void gfs2_recovery_done(struct gfs2_sbd
*sdp
, unsigned int jid
,
276 unsigned int message
)
280 char *envp
[] = { env_jid
, env_status
, NULL
};
281 struct lm_lockstruct
*ls
= &sdp
->sd_lockstruct
;
283 ls
->ls_recover_jid_done
= jid
;
284 ls
->ls_recover_jid_status
= message
;
285 sprintf(env_jid
, "JID=%u", jid
);
286 sprintf(env_status
, "RECOVERY=%s",
287 message
== LM_RD_SUCCESS
? "Done" : "Failed");
288 kobject_uevent_env(&sdp
->sd_kobj
, KOBJ_CHANGE
, envp
);
290 if (sdp
->sd_lockstruct
.ls_ops
->lm_recovery_result
)
291 sdp
->sd_lockstruct
.ls_ops
->lm_recovery_result(sdp
, jid
, message
);
294 void gfs2_recover_func(struct work_struct
*work
)
296 struct gfs2_jdesc
*jd
= container_of(work
, struct gfs2_jdesc
, jd_work
);
297 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
298 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
299 struct gfs2_log_header_host head
;
300 struct gfs2_holder j_gh
, ji_gh
, thaw_gh
;
301 ktime_t t_start
, t_jlck
, t_jhd
, t_tlck
, t_rep
;
307 t_start
= ktime_get();
308 if (sdp
->sd_args
.ar_spectator
)
310 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
) {
311 fs_info(sdp
, "jid=%u: Trying to acquire journal lock...\n",
314 /* Acquire the journal lock so we can do recovery */
316 error
= gfs2_glock_nq_num(sdp
, jd
->jd_jid
, &gfs2_journal_glops
,
318 LM_FLAG_NOEXP
| LM_FLAG_TRY
| GL_NOCACHE
,
325 fs_info(sdp
, "jid=%u: Busy\n", jd
->jd_jid
);
332 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
,
333 LM_FLAG_NOEXP
| GL_NOCACHE
, &ji_gh
);
337 fs_info(sdp
, "jid=%u, already locked for use\n", jd
->jd_jid
);
340 t_jlck
= ktime_get();
341 fs_info(sdp
, "jid=%u: Looking at journal...\n", jd
->jd_jid
);
343 error
= gfs2_jdesc_check(jd
);
345 goto fail_gunlock_ji
;
347 error
= gfs2_find_jhead(jd
, &head
);
349 goto fail_gunlock_ji
;
351 fs_info(sdp
, "jid=%u: Journal head lookup took %lldms\n", jd
->jd_jid
,
352 ktime_ms_delta(t_jhd
, t_jlck
));
354 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
355 fs_info(sdp
, "jid=%u: Acquiring the transaction lock...\n",
358 /* Acquire a shared hold on the freeze lock */
360 error
= gfs2_glock_nq_init(sdp
->sd_freeze_gl
, LM_ST_SHARED
,
361 LM_FLAG_NOEXP
| LM_FLAG_PRIORITY
,
364 goto fail_gunlock_ji
;
366 if (test_bit(SDF_RORECOVERY
, &sdp
->sd_flags
)) {
368 } else if (test_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
)) {
369 if (!test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
))
372 if (sb_rdonly(sdp
->sd_vfs
)) {
373 /* check if device itself is read-only */
374 ro
= bdev_read_only(sdp
->sd_vfs
->s_bdev
);
376 fs_info(sdp
, "recovery required on "
377 "read-only filesystem.\n");
378 fs_info(sdp
, "write access will be "
379 "enabled during recovery.\n");
385 fs_warn(sdp
, "jid=%u: Can't replay: read-only block "
386 "device\n", jd
->jd_jid
);
388 goto fail_gunlock_thaw
;
391 t_tlck
= ktime_get();
392 fs_info(sdp
, "jid=%u: Replaying journal...\n", jd
->jd_jid
);
394 for (pass
= 0; pass
< 2; pass
++) {
395 lops_before_scan(jd
, &head
, pass
);
396 error
= foreach_descriptor(jd
, head
.lh_tail
,
397 head
.lh_blkno
, pass
);
398 lops_after_scan(jd
, error
, pass
);
400 goto fail_gunlock_thaw
;
403 clean_journal(jd
, &head
);
405 gfs2_glock_dq_uninit(&thaw_gh
);
407 fs_info(sdp
, "jid=%u: Journal replayed in %lldms [jlck:%lldms, "
408 "jhead:%lldms, tlck:%lldms, replay:%lldms]\n",
409 jd
->jd_jid
, ktime_ms_delta(t_rep
, t_start
),
410 ktime_ms_delta(t_jlck
, t_start
),
411 ktime_ms_delta(t_jhd
, t_jlck
),
412 ktime_ms_delta(t_tlck
, t_jhd
),
413 ktime_ms_delta(t_rep
, t_tlck
));
416 gfs2_recovery_done(sdp
, jd
->jd_jid
, LM_RD_SUCCESS
);
419 gfs2_glock_dq_uninit(&ji_gh
);
420 gfs2_glock_dq_uninit(&j_gh
);
423 fs_info(sdp
, "jid=%u: Done\n", jd
->jd_jid
);
427 gfs2_glock_dq_uninit(&thaw_gh
);
430 gfs2_glock_dq_uninit(&ji_gh
);
432 gfs2_glock_dq_uninit(&j_gh
);
435 fs_info(sdp
, "jid=%u: %s\n", jd
->jd_jid
, (error
) ? "Failed" : "Done");
437 jd
->jd_recover_error
= error
;
438 gfs2_recovery_done(sdp
, jd
->jd_jid
, LM_RD_GAVEUP
);
440 clear_bit(JDF_RECOVERY
, &jd
->jd_flags
);
441 smp_mb__after_atomic();
442 wake_up_bit(&jd
->jd_flags
, JDF_RECOVERY
);
445 int gfs2_recover_journal(struct gfs2_jdesc
*jd
, bool wait
)
449 if (test_and_set_bit(JDF_RECOVERY
, &jd
->jd_flags
))
452 /* we have JDF_RECOVERY, queue should always succeed */
453 rv
= queue_work(gfs_recovery_wq
, &jd
->jd_work
);
457 wait_on_bit(&jd
->jd_flags
, JDF_RECOVERY
,
458 TASK_UNINTERRUPTIBLE
);
460 return wait
? jd
->jd_recover_error
: 0;