1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 4 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 5 */ 6 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> 16 17 #include "gfs2.h" 18 #include "incore.h" 19 #include "bmap.h" 20 #include "glock.h" 21 #include "glops.h" 22 #include "log.h" 23 #include "lops.h" 24 #include "meta_io.h" 25 #include "recovery.h" 26 #include "super.h" 27 #include "util.h" 28 #include "dir.h" 29 30 struct workqueue_struct *gfs_recovery_wq; 31 32 int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk, 33 struct buffer_head **bh) 34 { 35 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 36 struct gfs2_glock *gl = ip->i_gl; 37 int new = 0; 38 u64 dblock; 39 u32 extlen; 40 int error; 41 42 error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen); 43 if (error) 44 return error; 45 if (!dblock) { 46 gfs2_consist_inode(ip); 47 return -EIO; 48 } 49 50 *bh = gfs2_meta_ra(gl, dblock, extlen); 51 52 return error; 53 } 54 55 int gfs2_revoke_add(struct gfs2_jdesc *jd, u64 blkno, unsigned int where) 56 { 57 struct list_head *head = &jd->jd_revoke_list; 58 struct gfs2_revoke_replay *rr; 59 int found = 0; 60 61 list_for_each_entry(rr, head, rr_list) { 62 if (rr->rr_blkno == blkno) { 63 found = 1; 64 break; 65 } 66 } 67 68 if (found) { 69 rr->rr_where = where; 70 return 0; 71 } 72 73 rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_NOFS); 74 if (!rr) 75 return -ENOMEM; 76 77 rr->rr_blkno = blkno; 78 rr->rr_where = where; 79 list_add(&rr->rr_list, head); 80 81 return 1; 82 } 83 84 int gfs2_revoke_check(struct gfs2_jdesc *jd, u64 blkno, unsigned int where) 85 { 86 struct gfs2_revoke_replay *rr; 87 int wrap, a, b, revoke; 88 int found = 0; 89 90 list_for_each_entry(rr, &jd->jd_revoke_list, rr_list) { 91 if (rr->rr_blkno == blkno) { 92 found = 1; 93 break; 94 } 95 } 96 97 if (!found) 98 return 0; 99 100 wrap = (rr->rr_where < jd->jd_replay_tail); 101 a = (jd->jd_replay_tail < where); 102 b = (where < rr->rr_where); 103 revoke = (wrap) ? (a || b) : (a && b); 104 105 return revoke; 106 } 107 108 void gfs2_revoke_clean(struct gfs2_jdesc *jd) 109 { 110 struct list_head *head = &jd->jd_revoke_list; 111 struct gfs2_revoke_replay *rr; 112 113 while (!list_empty(head)) { 114 rr = list_first_entry(head, struct gfs2_revoke_replay, rr_list); 115 list_del(&rr->rr_list); 116 kfree(rr); 117 } 118 } 119 120 int __get_log_header(struct gfs2_sbd *sdp, const struct gfs2_log_header *lh, 121 unsigned int blkno, struct gfs2_log_header_host *head) 122 { 123 u32 hash, crc; 124 125 if (lh->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) || 126 lh->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH) || 127 (blkno && be32_to_cpu(lh->lh_blkno) != blkno)) 128 return 1; 129 130 hash = crc32(~0, lh, LH_V1_SIZE - 4); 131 hash = ~crc32_le_shift(hash, 4); /* assume lh_hash is zero */ 132 133 if (be32_to_cpu(lh->lh_hash) != hash) 134 return 1; 135 136 crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4, 137 sdp->sd_sb.sb_bsize - LH_V1_SIZE - 4); 138 139 if ((lh->lh_crc != 0 && be32_to_cpu(lh->lh_crc) != crc)) 140 return 1; 141 142 head->lh_sequence = be64_to_cpu(lh->lh_sequence); 143 head->lh_flags = be32_to_cpu(lh->lh_flags); 144 head->lh_tail = be32_to_cpu(lh->lh_tail); 145 head->lh_blkno = be32_to_cpu(lh->lh_blkno); 146 147 return 0; 148 } 149 /** 150 * get_log_header - read the log header for a given segment 151 * @jd: the journal 152 * @blk: the block to look at 153 * @lh: the log header to return 154 * 155 * Read the log header for a given segement in a given journal. Do a few 156 * sanity checks on it. 157 * 158 * Returns: 0 on success, 159 * 1 if the header was invalid or incomplete, 160 * errno on error 161 */ 162 163 static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk, 164 struct gfs2_log_header_host *head) 165 { 166 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 167 struct buffer_head *bh; 168 int error; 169 170 error = gfs2_replay_read_block(jd, blk, &bh); 171 if (error) 172 return error; 173 174 error = __get_log_header(sdp, (const struct gfs2_log_header *)bh->b_data, 175 blk, head); 176 brelse(bh); 177 178 return error; 179 } 180 181 /** 182 * foreach_descriptor - go through the active part of the log 183 * @jd: the journal 184 * @start: the first log header in the active region 185 * @end: the last log header (don't process the contents of this entry)) 186 * 187 * Call a given function once for every log descriptor in the active 188 * portion of the log. 189 * 190 * Returns: errno 191 */ 192 193 static int foreach_descriptor(struct gfs2_jdesc *jd, u32 start, 194 unsigned int end, int pass) 195 { 196 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 197 struct buffer_head *bh; 198 struct gfs2_log_descriptor *ld; 199 int error = 0; 200 u32 length; 201 __be64 *ptr; 202 unsigned int offset = sizeof(struct gfs2_log_descriptor); 203 offset += sizeof(__be64) - 1; 204 offset &= ~(sizeof(__be64) - 1); 205 206 while (start != end) { 207 error = gfs2_replay_read_block(jd, start, &bh); 208 if (error) 209 return error; 210 if (gfs2_meta_check(sdp, bh)) { 211 brelse(bh); 212 return -EIO; 213 } 214 ld = (struct gfs2_log_descriptor *)bh->b_data; 215 length = be32_to_cpu(ld->ld_length); 216 217 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) { 218 struct gfs2_log_header_host lh; 219 error = get_log_header(jd, start, &lh); 220 if (!error) { 221 gfs2_replay_incr_blk(jd, &start); 222 brelse(bh); 223 continue; 224 } 225 if (error == 1) { 226 gfs2_consist_inode(GFS2_I(jd->jd_inode)); 227 error = -EIO; 228 } 229 brelse(bh); 230 return error; 231 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) { 232 brelse(bh); 233 return -EIO; 234 } 235 ptr = (__be64 *)(bh->b_data + offset); 236 error = lops_scan_elements(jd, start, ld, ptr, pass); 237 if (error) { 238 brelse(bh); 239 return error; 240 } 241 242 while (length--) 243 gfs2_replay_incr_blk(jd, &start); 244 245 brelse(bh); 246 } 247 248 return 0; 249 } 250 251 /** 252 * clean_journal - mark a dirty journal as being clean 253 * @jd: the journal 254 * @head: the head journal to start from 255 * 256 * Returns: errno 257 */ 258 259 static void clean_journal(struct gfs2_jdesc *jd, 260 struct gfs2_log_header_host *head) 261 { 262 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 263 u32 lblock = head->lh_blkno; 264 265 gfs2_replay_incr_blk(jd, &lblock); 266 gfs2_write_log_header(sdp, jd, head->lh_sequence + 1, 0, lblock, 267 GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY, 268 REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC); 269 if (jd->jd_jid == sdp->sd_lockstruct.ls_jid) { 270 sdp->sd_log_flush_head = lblock; 271 gfs2_log_incr_head(sdp); 272 } 273 } 274 275 276 static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, 277 unsigned int message) 278 { 279 char env_jid[20]; 280 char env_status[20]; 281 char *envp[] = { env_jid, env_status, NULL }; 282 struct lm_lockstruct *ls = &sdp->sd_lockstruct; 283 284 ls->ls_recover_jid_done = jid; 285 ls->ls_recover_jid_status = message; 286 sprintf(env_jid, "JID=%u", jid); 287 sprintf(env_status, "RECOVERY=%s", 288 message == LM_RD_SUCCESS ? "Done" : "Failed"); 289 kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp); 290 291 if (sdp->sd_lockstruct.ls_ops->lm_recovery_result) 292 sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message); 293 } 294 295 void gfs2_recover_func(struct work_struct *work) 296 { 297 struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work); 298 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 299 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 300 struct gfs2_log_header_host head; 301 struct gfs2_holder j_gh, ji_gh, thaw_gh; 302 ktime_t t_start, t_jlck, t_jhd, t_tlck, t_rep; 303 int ro = 0; 304 unsigned int pass; 305 int error = 0; 306 int jlocked = 0; 307 308 if (gfs2_withdrawn(sdp)) { 309 fs_err(sdp, "jid=%u: Recovery not attempted due to withdraw.\n", 310 jd->jd_jid); 311 goto fail; 312 } 313 t_start = ktime_get(); 314 if (sdp->sd_args.ar_spectator) 315 goto fail; 316 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { 317 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", 318 jd->jd_jid); 319 jlocked = 1; 320 /* Acquire the journal lock so we can do recovery */ 321 322 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops, 323 LM_ST_EXCLUSIVE, 324 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE, 325 &j_gh); 326 switch (error) { 327 case 0: 328 break; 329 330 case GLR_TRYFAILED: 331 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid); 332 error = 0; 333 334 default: 335 goto fail; 336 } 337 338 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 339 LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); 340 if (error) 341 goto fail_gunlock_j; 342 } else { 343 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid); 344 } 345 346 t_jlck = ktime_get(); 347 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid); 348 349 error = gfs2_jdesc_check(jd); 350 if (error) 351 goto fail_gunlock_ji; 352 353 error = gfs2_find_jhead(jd, &head, true); 354 if (error) 355 goto fail_gunlock_ji; 356 t_jhd = ktime_get(); 357 fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid, 358 ktime_ms_delta(t_jhd, t_jlck)); 359 360 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 361 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n", 362 jd->jd_jid); 363 364 /* Acquire a shared hold on the freeze lock */ 365 366 error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 367 LM_FLAG_NOEXP | LM_FLAG_PRIORITY, 368 &thaw_gh); 369 if (error) 370 goto fail_gunlock_ji; 371 372 if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) { 373 ro = 1; 374 } else if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { 375 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) 376 ro = 1; 377 } else { 378 if (sb_rdonly(sdp->sd_vfs)) { 379 /* check if device itself is read-only */ 380 ro = bdev_read_only(sdp->sd_vfs->s_bdev); 381 if (!ro) { 382 fs_info(sdp, "recovery required on " 383 "read-only filesystem.\n"); 384 fs_info(sdp, "write access will be " 385 "enabled during recovery.\n"); 386 } 387 } 388 } 389 390 if (ro) { 391 fs_warn(sdp, "jid=%u: Can't replay: read-only block " 392 "device\n", jd->jd_jid); 393 error = -EROFS; 394 goto fail_gunlock_thaw; 395 } 396 397 t_tlck = ktime_get(); 398 fs_info(sdp, "jid=%u: Replaying journal...0x%x to 0x%x\n", 399 jd->jd_jid, head.lh_tail, head.lh_blkno); 400 401 /* We take the sd_log_flush_lock here primarily to prevent log 402 * flushes and simultaneous journal replays from stomping on 403 * each other wrt sd_log_bio. */ 404 down_read(&sdp->sd_log_flush_lock); 405 for (pass = 0; pass < 2; pass++) { 406 lops_before_scan(jd, &head, pass); 407 error = foreach_descriptor(jd, head.lh_tail, 408 head.lh_blkno, pass); 409 lops_after_scan(jd, error, pass); 410 if (error) 411 goto fail_gunlock_thaw; 412 } 413 414 clean_journal(jd, &head); 415 up_read(&sdp->sd_log_flush_lock); 416 417 gfs2_glock_dq_uninit(&thaw_gh); 418 t_rep = ktime_get(); 419 fs_info(sdp, "jid=%u: Journal replayed in %lldms [jlck:%lldms, " 420 "jhead:%lldms, tlck:%lldms, replay:%lldms]\n", 421 jd->jd_jid, ktime_ms_delta(t_rep, t_start), 422 ktime_ms_delta(t_jlck, t_start), 423 ktime_ms_delta(t_jhd, t_jlck), 424 ktime_ms_delta(t_tlck, t_jhd), 425 ktime_ms_delta(t_rep, t_tlck)); 426 } 427 428 gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS); 429 430 if (jlocked) { 431 gfs2_glock_dq_uninit(&ji_gh); 432 gfs2_glock_dq_uninit(&j_gh); 433 } 434 435 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid); 436 goto done; 437 438 fail_gunlock_thaw: 439 gfs2_glock_dq_uninit(&thaw_gh); 440 fail_gunlock_ji: 441 if (jlocked) { 442 gfs2_glock_dq_uninit(&ji_gh); 443 fail_gunlock_j: 444 gfs2_glock_dq_uninit(&j_gh); 445 } 446 447 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done"); 448 fail: 449 jd->jd_recover_error = error; 450 gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP); 451 done: 452 clear_bit(JDF_RECOVERY, &jd->jd_flags); 453 smp_mb__after_atomic(); 454 wake_up_bit(&jd->jd_flags, JDF_RECOVERY); 455 } 456 457 int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait) 458 { 459 int rv; 460 461 if (test_and_set_bit(JDF_RECOVERY, &jd->jd_flags)) 462 return -EBUSY; 463 464 /* we have JDF_RECOVERY, queue should always succeed */ 465 rv = queue_work(gfs_recovery_wq, &jd->jd_work); 466 BUG_ON(!rv); 467 468 if (wait) 469 wait_on_bit(&jd->jd_flags, JDF_RECOVERY, 470 TASK_UNINTERRUPTIBLE); 471 472 return wait ? jd->jd_recover_error : 0; 473 } 474 475