]>
git.proxmox.com Git - mirror_ubuntu-bionic-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 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 <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
, uint64_t 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
, uint64_t 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 uint32_t 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
);
331 gfs2_consist_inode(GFS2_I(jd
->jd_inode
));
336 } else if (gfs2_metatype_check(sdp
, bh
, GFS2_METATYPE_LD
)) {
340 ptr
= (__be64
*)(bh
->b_data
+ offset
);
341 error
= lops_scan_elements(jd
, start
, ld
, ptr
, pass
);
348 gfs2_replay_incr_blk(sdp
, &start
);
357 * clean_journal - mark a dirty journal as being clean
358 * @sdp: the filesystem
360 * @gl: the journal's glock
361 * @head: the head journal to start from
366 static int clean_journal(struct gfs2_jdesc
*jd
, struct gfs2_log_header
*head
)
368 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
369 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
373 struct gfs2_log_header
*lh
;
375 struct buffer_head
*bh
;
379 lblock
= head
->lh_blkno
;
380 gfs2_replay_incr_blk(sdp
, &lblock
);
381 error
= gfs2_block_map(&ip
->i_inode
, lblock
, &new, &dblock
, &boundary
);
385 gfs2_consist_inode(ip
);
389 bh
= sb_getblk(sdp
->sd_vfs
, dblock
);
391 memset(bh
->b_data
, 0, bh
->b_size
);
392 set_buffer_uptodate(bh
);
393 clear_buffer_dirty(bh
);
396 lh
= (struct gfs2_log_header
*)bh
->b_data
;
397 memset(lh
, 0, sizeof(struct gfs2_log_header
));
398 lh
->lh_header
.mh_magic
= cpu_to_be32(GFS2_MAGIC
);
399 lh
->lh_header
.mh_type
= cpu_to_be16(GFS2_METATYPE_LH
);
400 lh
->lh_header
.mh_format
= cpu_to_be32(GFS2_FORMAT_LH
);
401 lh
->lh_sequence
= cpu_to_be64(head
->lh_sequence
+ 1);
402 lh
->lh_flags
= cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT
);
403 lh
->lh_blkno
= cpu_to_be32(lblock
);
404 hash
= gfs2_disk_hash((const char *)lh
, sizeof(struct gfs2_log_header
));
405 lh
->lh_hash
= cpu_to_be32(hash
);
407 set_buffer_dirty(bh
);
408 if (sync_dirty_buffer(bh
))
409 gfs2_io_error_bh(sdp
, bh
);
416 * gfs2_recover_journal - recovery a given journal
417 * @jd: the struct gfs2_jdesc describing the journal
419 * Acquire the journal's lock, check to see if the journal is clean, and
420 * do recovery if necessary.
425 int gfs2_recover_journal(struct gfs2_jdesc
*jd
)
427 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
428 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
429 struct gfs2_log_header head
;
430 struct gfs2_holder j_gh
, ji_gh
, t_gh
;
436 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
) {
437 fs_info(sdp
, "jid=%u: Trying to acquire journal lock...\n",
440 /* Aquire the journal lock so we can do recovery */
442 error
= gfs2_glock_nq_num(sdp
, jd
->jd_jid
, &gfs2_journal_glops
,
444 LM_FLAG_NOEXP
| LM_FLAG_TRY
| GL_NOCACHE
,
451 fs_info(sdp
, "jid=%u: Busy\n", jd
->jd_jid
);
458 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
,
459 LM_FLAG_NOEXP
, &ji_gh
);
463 fs_info(sdp
, "jid=%u, already locked for use\n", jd
->jd_jid
);
466 fs_info(sdp
, "jid=%u: Looking at journal...\n", jd
->jd_jid
);
468 error
= gfs2_jdesc_check(jd
);
470 goto fail_gunlock_ji
;
472 error
= gfs2_find_jhead(jd
, &head
);
474 goto fail_gunlock_ji
;
476 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
477 fs_info(sdp
, "jid=%u: Acquiring the transaction lock...\n",
482 /* Acquire a shared hold on the transaction lock */
484 error
= gfs2_glock_nq_init(sdp
->sd_trans_gl
, LM_ST_SHARED
,
485 LM_FLAG_NOEXP
| LM_FLAG_PRIORITY
|
486 GL_NOCANCEL
| GL_NOCACHE
, &t_gh
);
488 goto fail_gunlock_ji
;
490 if (test_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
)) {
491 if (!test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
))
494 if (sdp
->sd_vfs
->s_flags
& MS_RDONLY
)
499 fs_warn(sdp
, "jid=%u: Can't replay: read-only FS\n",
502 goto fail_gunlock_tr
;
505 fs_info(sdp
, "jid=%u: Replaying journal...\n", jd
->jd_jid
);
507 for (pass
= 0; pass
< 2; pass
++) {
508 lops_before_scan(jd
, &head
, pass
);
509 error
= foreach_descriptor(jd
, head
.lh_tail
,
510 head
.lh_blkno
, pass
);
511 lops_after_scan(jd
, error
, pass
);
513 goto fail_gunlock_tr
;
516 error
= clean_journal(jd
, &head
);
518 goto fail_gunlock_tr
;
520 gfs2_glock_dq_uninit(&t_gh
);
521 t
= DIV_ROUND_UP(jiffies
- t
, HZ
);
522 fs_info(sdp
, "jid=%u: Journal replayed in %lus\n",
526 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
)
527 gfs2_glock_dq_uninit(&ji_gh
);
529 gfs2_lm_recovery_done(sdp
, jd
->jd_jid
, LM_RD_SUCCESS
);
531 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
)
532 gfs2_glock_dq_uninit(&j_gh
);
534 fs_info(sdp
, "jid=%u: Done\n", jd
->jd_jid
);
538 gfs2_glock_dq_uninit(&t_gh
);
540 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
) {
541 gfs2_glock_dq_uninit(&ji_gh
);
543 gfs2_glock_dq_uninit(&j_gh
);
546 fs_info(sdp
, "jid=%u: %s\n", jd
->jd_jid
, (error
) ? "Failed" : "Done");
549 gfs2_lm_recovery_done(sdp
, jd
->jd_jid
, LM_RD_GAVEUP
);
554 * gfs2_check_journals - Recover any dirty journals
555 * @sdp: the filesystem
559 void gfs2_check_journals(struct gfs2_sbd
*sdp
)
561 struct gfs2_jdesc
*jd
;
564 jd
= gfs2_jdesc_find_dirty(sdp
);
568 if (jd
!= sdp
->sd_jdesc
)
569 gfs2_recover_journal(jd
);