1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
7 #include <linux/module.h>
8 #include <linux/slab.h>
9 #include <linux/spinlock.h>
10 #include <linux/completion.h>
11 #include <linux/buffer_head.h>
12 #include <linux/gfs2_ondisk.h>
13 #include <linux/crc32.h>
14 #include <linux/crc32c.h>
15 #include <linux/ktime.h>
30 struct workqueue_struct
*gfs_recovery_wq
;
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_get_extent(&ip
->i_inode
, blk
, &dblock
, &extlen
);
46 gfs2_consist_inode(ip
);
50 *bh
= gfs2_meta_ra(gl
, dblock
, extlen
);
55 int gfs2_revoke_add(struct gfs2_jdesc
*jd
, u64 blkno
, unsigned int where
)
57 struct list_head
*head
= &jd
->jd_revoke_list
;
58 struct gfs2_revoke_replay
*rr
= NULL
, *iter
;
60 list_for_each_entry(iter
, head
, rr_list
) {
61 if (iter
->rr_blkno
== blkno
) {
72 rr
= kmalloc(sizeof(struct gfs2_revoke_replay
), GFP_NOFS
);
78 list_add(&rr
->rr_list
, head
);
83 int gfs2_revoke_check(struct gfs2_jdesc
*jd
, u64 blkno
, unsigned int where
)
85 struct gfs2_revoke_replay
*rr
= NULL
, *iter
;
86 int wrap
, a
, b
, revoke
;
88 list_for_each_entry(iter
, &jd
->jd_revoke_list
, rr_list
) {
89 if (iter
->rr_blkno
== blkno
) {
98 wrap
= (rr
->rr_where
< jd
->jd_replay_tail
);
99 a
= (jd
->jd_replay_tail
< where
);
100 b
= (where
< rr
->rr_where
);
101 revoke
= (wrap
) ? (a
|| b
) : (a
&& b
);
106 void gfs2_revoke_clean(struct gfs2_jdesc
*jd
)
108 struct list_head
*head
= &jd
->jd_revoke_list
;
109 struct gfs2_revoke_replay
*rr
;
111 while (!list_empty(head
)) {
112 rr
= list_first_entry(head
, struct gfs2_revoke_replay
, rr_list
);
113 list_del(&rr
->rr_list
);
118 int __get_log_header(struct gfs2_sbd
*sdp
, const struct gfs2_log_header
*lh
,
119 unsigned int blkno
, struct gfs2_log_header_host
*head
)
123 if (lh
->lh_header
.mh_magic
!= cpu_to_be32(GFS2_MAGIC
) ||
124 lh
->lh_header
.mh_type
!= cpu_to_be32(GFS2_METATYPE_LH
) ||
125 (blkno
&& be32_to_cpu(lh
->lh_blkno
) != blkno
))
128 hash
= crc32(~0, lh
, LH_V1_SIZE
- 4);
129 hash
= ~crc32_le_shift(hash
, 4); /* assume lh_hash is zero */
131 if (be32_to_cpu(lh
->lh_hash
) != hash
)
134 crc
= crc32c(~0, (void *)lh
+ LH_V1_SIZE
+ 4,
135 sdp
->sd_sb
.sb_bsize
- LH_V1_SIZE
- 4);
137 if ((lh
->lh_crc
!= 0 && be32_to_cpu(lh
->lh_crc
) != crc
))
140 head
->lh_sequence
= be64_to_cpu(lh
->lh_sequence
);
141 head
->lh_flags
= be32_to_cpu(lh
->lh_flags
);
142 head
->lh_tail
= be32_to_cpu(lh
->lh_tail
);
143 head
->lh_blkno
= be32_to_cpu(lh
->lh_blkno
);
145 head
->lh_local_total
= be64_to_cpu(lh
->lh_local_total
);
146 head
->lh_local_free
= be64_to_cpu(lh
->lh_local_free
);
147 head
->lh_local_dinodes
= be64_to_cpu(lh
->lh_local_dinodes
);
152 * get_log_header - read the log header for a given segment
154 * @blk: the block to look at
155 * @head: the log header to return
157 * Read the log header for a given segement in a given journal. Do a few
158 * sanity checks on it.
160 * Returns: 0 on success,
161 * 1 if the header was invalid or incomplete,
165 static int get_log_header(struct gfs2_jdesc
*jd
, unsigned int blk
,
166 struct gfs2_log_header_host
*head
)
168 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
169 struct buffer_head
*bh
;
172 error
= gfs2_replay_read_block(jd
, blk
, &bh
);
176 error
= __get_log_header(sdp
, (const struct gfs2_log_header
*)bh
->b_data
,
184 * foreach_descriptor - go through the active part of the log
186 * @start: the first log header in the active region
187 * @end: the last log header (don't process the contents of this entry))
188 * @pass: iteration number (foreach_descriptor() is called in a for() loop)
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
, u32 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
);
266 u32 lblock
= head
->lh_blkno
;
268 gfs2_replay_incr_blk(jd
, &lblock
);
269 gfs2_write_log_header(sdp
, jd
, head
->lh_sequence
+ 1, 0, lblock
,
270 GFS2_LOG_HEAD_UNMOUNT
| GFS2_LOG_HEAD_RECOVERY
,
271 REQ_PREFLUSH
| REQ_FUA
| REQ_META
| REQ_SYNC
);
272 if (jd
->jd_jid
== sdp
->sd_lockstruct
.ls_jid
) {
273 sdp
->sd_log_flush_head
= lblock
;
274 gfs2_log_incr_head(sdp
);
279 static void gfs2_recovery_done(struct gfs2_sbd
*sdp
, unsigned int jid
,
280 unsigned int message
)
284 char *envp
[] = { env_jid
, env_status
, NULL
};
285 struct lm_lockstruct
*ls
= &sdp
->sd_lockstruct
;
287 ls
->ls_recover_jid_done
= jid
;
288 ls
->ls_recover_jid_status
= message
;
289 sprintf(env_jid
, "JID=%u", jid
);
290 sprintf(env_status
, "RECOVERY=%s",
291 message
== LM_RD_SUCCESS
? "Done" : "Failed");
292 kobject_uevent_env(&sdp
->sd_kobj
, KOBJ_CHANGE
, envp
);
294 if (sdp
->sd_lockstruct
.ls_ops
->lm_recovery_result
)
295 sdp
->sd_lockstruct
.ls_ops
->lm_recovery_result(sdp
, jid
, message
);
299 * update_statfs_inode - Update the master statfs inode or zero out the local
300 * statfs inode for a given journal.
302 * @head: If NULL, @inode is the local statfs inode and we need to zero it out.
303 * Otherwise, it @head contains the statfs change info that needs to be
304 * synced to the master statfs inode (pointed to by @inode).
305 * @inode: statfs inode to update.
307 static int update_statfs_inode(struct gfs2_jdesc
*jd
,
308 struct gfs2_log_header_host
*head
,
311 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
312 struct gfs2_inode
*ip
;
313 struct buffer_head
*bh
;
314 struct gfs2_statfs_change_host sc
;
320 error
= gfs2_meta_inode_buffer(ip
, &bh
);
324 spin_lock(&sdp
->sd_statfs_spin
);
326 if (head
) { /* Update the master statfs inode */
327 gfs2_statfs_change_in(&sc
, bh
->b_data
+ sizeof(struct gfs2_dinode
));
328 sc
.sc_total
+= head
->lh_local_total
;
329 sc
.sc_free
+= head
->lh_local_free
;
330 sc
.sc_dinodes
+= head
->lh_local_dinodes
;
331 gfs2_statfs_change_out(&sc
, bh
->b_data
+ sizeof(struct gfs2_dinode
));
333 fs_info(sdp
, "jid=%u: Updated master statfs Total:%lld, "
334 "Free:%lld, Dinodes:%lld after change "
335 "[%+lld,%+lld,%+lld]\n", jd
->jd_jid
, sc
.sc_total
,
336 sc
.sc_free
, sc
.sc_dinodes
, head
->lh_local_total
,
337 head
->lh_local_free
, head
->lh_local_dinodes
);
338 } else { /* Zero out the local statfs inode */
339 memset(bh
->b_data
+ sizeof(struct gfs2_dinode
), 0,
340 sizeof(struct gfs2_statfs_change
));
341 /* If it's our own journal, reset any in-memory changes too */
342 if (jd
->jd_jid
== sdp
->sd_lockstruct
.ls_jid
) {
343 memset(&sdp
->sd_statfs_local
, 0,
344 sizeof(struct gfs2_statfs_change_host
));
347 spin_unlock(&sdp
->sd_statfs_spin
);
349 mark_buffer_dirty(bh
);
351 gfs2_inode_metasync(ip
->i_gl
);
358 * recover_local_statfs - Update the master and local statfs changes for this
361 * Previously, statfs updates would be read in from the local statfs inode and
362 * synced to the master statfs inode during recovery.
364 * We now use the statfs updates in the journal head to update the master statfs
365 * inode instead of reading in from the local statfs inode. To preserve backward
366 * compatibility with kernels that can't do this, we still need to keep the
367 * local statfs inode up to date by writing changes to it. At some point in the
368 * future, we can do away with the local statfs inodes altogether and keep the
369 * statfs changes solely in the journal.
372 * @head: the journal head
376 static void recover_local_statfs(struct gfs2_jdesc
*jd
,
377 struct gfs2_log_header_host
*head
)
380 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
382 if (!head
->lh_local_total
&& !head
->lh_local_free
383 && !head
->lh_local_dinodes
) /* No change */
386 /* First update the master statfs inode with the changes we
387 * found in the journal. */
388 error
= update_statfs_inode(jd
, head
, sdp
->sd_statfs_inode
);
393 /* Zero out the local statfs inode so any changes in there
394 * are not re-recovered. */
395 error
= update_statfs_inode(jd
, NULL
,
396 find_local_statfs_inode(sdp
, jd
->jd_jid
));
401 void gfs2_recover_func(struct work_struct
*work
)
403 struct gfs2_jdesc
*jd
= container_of(work
, struct gfs2_jdesc
, jd_work
);
404 struct gfs2_inode
*ip
= GFS2_I(jd
->jd_inode
);
405 struct gfs2_sbd
*sdp
= GFS2_SB(jd
->jd_inode
);
406 struct gfs2_log_header_host head
;
407 struct gfs2_holder j_gh
, ji_gh
, thaw_gh
;
408 ktime_t t_start
, t_jlck
, t_jhd
, t_tlck
, t_rep
;
414 if (gfs2_withdrawn(sdp
)) {
415 fs_err(sdp
, "jid=%u: Recovery not attempted due to withdraw.\n",
419 t_start
= ktime_get();
420 if (sdp
->sd_args
.ar_spectator
)
422 if (jd
->jd_jid
!= sdp
->sd_lockstruct
.ls_jid
) {
423 fs_info(sdp
, "jid=%u: Trying to acquire journal lock...\n",
426 /* Acquire the journal lock so we can do recovery */
428 error
= gfs2_glock_nq_num(sdp
, jd
->jd_jid
, &gfs2_journal_glops
,
430 LM_FLAG_NOEXP
| LM_FLAG_TRY
| GL_NOCACHE
,
437 fs_info(sdp
, "jid=%u: Busy\n", jd
->jd_jid
);
445 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
,
446 LM_FLAG_NOEXP
| GL_NOCACHE
, &ji_gh
);
450 fs_info(sdp
, "jid=%u, already locked for use\n", jd
->jd_jid
);
453 t_jlck
= ktime_get();
454 fs_info(sdp
, "jid=%u: Looking at journal...\n", jd
->jd_jid
);
456 error
= gfs2_jdesc_check(jd
);
458 goto fail_gunlock_ji
;
460 error
= gfs2_find_jhead(jd
, &head
, true);
462 goto fail_gunlock_ji
;
464 fs_info(sdp
, "jid=%u: Journal head lookup took %lldms\n", jd
->jd_jid
,
465 ktime_ms_delta(t_jhd
, t_jlck
));
467 if (!(head
.lh_flags
& GFS2_LOG_HEAD_UNMOUNT
)) {
468 fs_info(sdp
, "jid=%u: Acquiring the transaction lock...\n",
471 /* Acquire a shared hold on the freeze lock */
473 error
= gfs2_freeze_lock(sdp
, &thaw_gh
, LM_FLAG_PRIORITY
);
475 goto fail_gunlock_ji
;
477 if (test_bit(SDF_RORECOVERY
, &sdp
->sd_flags
)) {
479 } else if (test_bit(SDF_JOURNAL_CHECKED
, &sdp
->sd_flags
)) {
480 if (!test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
))
483 if (sb_rdonly(sdp
->sd_vfs
)) {
484 /* check if device itself is read-only */
485 ro
= bdev_read_only(sdp
->sd_vfs
->s_bdev
);
487 fs_info(sdp
, "recovery required on "
488 "read-only filesystem.\n");
489 fs_info(sdp
, "write access will be "
490 "enabled during recovery.\n");
496 fs_warn(sdp
, "jid=%u: Can't replay: read-only block "
497 "device\n", jd
->jd_jid
);
499 goto fail_gunlock_thaw
;
502 t_tlck
= ktime_get();
503 fs_info(sdp
, "jid=%u: Replaying journal...0x%x to 0x%x\n",
504 jd
->jd_jid
, head
.lh_tail
, head
.lh_blkno
);
506 /* We take the sd_log_flush_lock here primarily to prevent log
507 * flushes and simultaneous journal replays from stomping on
508 * each other wrt jd_log_bio. */
509 down_read(&sdp
->sd_log_flush_lock
);
510 for (pass
= 0; pass
< 2; pass
++) {
511 lops_before_scan(jd
, &head
, pass
);
512 error
= foreach_descriptor(jd
, head
.lh_tail
,
513 head
.lh_blkno
, pass
);
514 lops_after_scan(jd
, error
, pass
);
516 up_read(&sdp
->sd_log_flush_lock
);
517 goto fail_gunlock_thaw
;
521 recover_local_statfs(jd
, &head
);
522 clean_journal(jd
, &head
);
523 up_read(&sdp
->sd_log_flush_lock
);
525 gfs2_freeze_unlock(&thaw_gh
);
527 fs_info(sdp
, "jid=%u: Journal replayed in %lldms [jlck:%lldms, "
528 "jhead:%lldms, tlck:%lldms, replay:%lldms]\n",
529 jd
->jd_jid
, ktime_ms_delta(t_rep
, t_start
),
530 ktime_ms_delta(t_jlck
, t_start
),
531 ktime_ms_delta(t_jhd
, t_jlck
),
532 ktime_ms_delta(t_tlck
, t_jhd
),
533 ktime_ms_delta(t_rep
, t_tlck
));
536 gfs2_recovery_done(sdp
, jd
->jd_jid
, LM_RD_SUCCESS
);
539 gfs2_glock_dq_uninit(&ji_gh
);
540 gfs2_glock_dq_uninit(&j_gh
);
543 fs_info(sdp
, "jid=%u: Done\n", jd
->jd_jid
);
547 gfs2_freeze_unlock(&thaw_gh
);
550 gfs2_glock_dq_uninit(&ji_gh
);
552 gfs2_glock_dq_uninit(&j_gh
);
555 fs_info(sdp
, "jid=%u: %s\n", jd
->jd_jid
, (error
) ? "Failed" : "Done");
557 jd
->jd_recover_error
= error
;
558 gfs2_recovery_done(sdp
, jd
->jd_jid
, LM_RD_GAVEUP
);
560 clear_bit(JDF_RECOVERY
, &jd
->jd_flags
);
561 smp_mb__after_atomic();
562 wake_up_bit(&jd
->jd_flags
, JDF_RECOVERY
);
565 int gfs2_recover_journal(struct gfs2_jdesc
*jd
, bool wait
)
569 if (test_and_set_bit(JDF_RECOVERY
, &jd
->jd_flags
))
572 /* we have JDF_RECOVERY, queue should always succeed */
573 rv
= queue_work(gfs_recovery_wq
, &jd
->jd_work
);
577 wait_on_bit(&jd
->jd_flags
, JDF_RECOVERY
,
578 TASK_UNINTERRUPTIBLE
);
580 return wait
? jd
->jd_recover_error
: 0;