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 u64 dblock; 38 u32 extlen; 39 int error; 40 41 extlen = 32; 42 error = gfs2_get_extent(&ip->i_inode, blk, &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 head->lh_local_total = be64_to_cpu(lh->lh_local_total); 148 head->lh_local_free = be64_to_cpu(lh->lh_local_free); 149 head->lh_local_dinodes = be64_to_cpu(lh->lh_local_dinodes); 150 151 return 0; 152 } 153 /** 154 * get_log_header - read the log header for a given segment 155 * @jd: the journal 156 * @blk: the block to look at 157 * @head: the log header to return 158 * 159 * Read the log header for a given segement in a given journal. Do a few 160 * sanity checks on it. 161 * 162 * Returns: 0 on success, 163 * 1 if the header was invalid or incomplete, 164 * errno on error 165 */ 166 167 static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk, 168 struct gfs2_log_header_host *head) 169 { 170 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 171 struct buffer_head *bh; 172 int error; 173 174 error = gfs2_replay_read_block(jd, blk, &bh); 175 if (error) 176 return error; 177 178 error = __get_log_header(sdp, (const struct gfs2_log_header *)bh->b_data, 179 blk, head); 180 brelse(bh); 181 182 return error; 183 } 184 185 /** 186 * foreach_descriptor - go through the active part of the log 187 * @jd: the journal 188 * @start: the first log header in the active region 189 * @end: the last log header (don't process the contents of this entry)) 190 * @pass: iteration number (foreach_descriptor() is called in a for() loop) 191 * 192 * Call a given function once for every log descriptor in the active 193 * portion of the log. 194 * 195 * Returns: errno 196 */ 197 198 static int foreach_descriptor(struct gfs2_jdesc *jd, u32 start, 199 unsigned int end, int pass) 200 { 201 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 202 struct buffer_head *bh; 203 struct gfs2_log_descriptor *ld; 204 int error = 0; 205 u32 length; 206 __be64 *ptr; 207 unsigned int offset = sizeof(struct gfs2_log_descriptor); 208 offset += sizeof(__be64) - 1; 209 offset &= ~(sizeof(__be64) - 1); 210 211 while (start != end) { 212 error = gfs2_replay_read_block(jd, start, &bh); 213 if (error) 214 return error; 215 if (gfs2_meta_check(sdp, bh)) { 216 brelse(bh); 217 return -EIO; 218 } 219 ld = (struct gfs2_log_descriptor *)bh->b_data; 220 length = be32_to_cpu(ld->ld_length); 221 222 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) { 223 struct gfs2_log_header_host lh; 224 error = get_log_header(jd, start, &lh); 225 if (!error) { 226 gfs2_replay_incr_blk(jd, &start); 227 brelse(bh); 228 continue; 229 } 230 if (error == 1) { 231 gfs2_consist_inode(GFS2_I(jd->jd_inode)); 232 error = -EIO; 233 } 234 brelse(bh); 235 return error; 236 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) { 237 brelse(bh); 238 return -EIO; 239 } 240 ptr = (__be64 *)(bh->b_data + offset); 241 error = lops_scan_elements(jd, start, ld, ptr, pass); 242 if (error) { 243 brelse(bh); 244 return error; 245 } 246 247 while (length--) 248 gfs2_replay_incr_blk(jd, &start); 249 250 brelse(bh); 251 } 252 253 return 0; 254 } 255 256 /** 257 * clean_journal - mark a dirty journal as being clean 258 * @jd: the journal 259 * @head: the head journal to start from 260 * 261 * Returns: errno 262 */ 263 264 static void clean_journal(struct gfs2_jdesc *jd, 265 struct gfs2_log_header_host *head) 266 { 267 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 268 u32 lblock = head->lh_blkno; 269 270 gfs2_replay_incr_blk(jd, &lblock); 271 gfs2_write_log_header(sdp, jd, head->lh_sequence + 1, 0, lblock, 272 GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY, 273 REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC); 274 if (jd->jd_jid == sdp->sd_lockstruct.ls_jid) { 275 sdp->sd_log_flush_head = lblock; 276 gfs2_log_incr_head(sdp); 277 } 278 } 279 280 281 static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, 282 unsigned int message) 283 { 284 char env_jid[20]; 285 char env_status[20]; 286 char *envp[] = { env_jid, env_status, NULL }; 287 struct lm_lockstruct *ls = &sdp->sd_lockstruct; 288 289 ls->ls_recover_jid_done = jid; 290 ls->ls_recover_jid_status = message; 291 sprintf(env_jid, "JID=%u", jid); 292 sprintf(env_status, "RECOVERY=%s", 293 message == LM_RD_SUCCESS ? "Done" : "Failed"); 294 kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp); 295 296 if (sdp->sd_lockstruct.ls_ops->lm_recovery_result) 297 sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message); 298 } 299 300 /** 301 * update_statfs_inode - Update the master statfs inode or zero out the local 302 * statfs inode for a given journal. 303 * @jd: The journal 304 * @head: If NULL, @inode is the local statfs inode and we need to zero it out. 305 * Otherwise, it @head contains the statfs change info that needs to be 306 * synced to the master statfs inode (pointed to by @inode). 307 * @inode: statfs inode to update. 308 */ 309 static int update_statfs_inode(struct gfs2_jdesc *jd, 310 struct gfs2_log_header_host *head, 311 struct inode *inode) 312 { 313 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 314 struct gfs2_inode *ip; 315 struct buffer_head *bh; 316 struct gfs2_statfs_change_host sc; 317 int error = 0; 318 319 BUG_ON(!inode); 320 ip = GFS2_I(inode); 321 322 error = gfs2_meta_inode_buffer(ip, &bh); 323 if (error) 324 goto out; 325 326 spin_lock(&sdp->sd_statfs_spin); 327 328 if (head) { /* Update the master statfs inode */ 329 gfs2_statfs_change_in(&sc, bh->b_data + sizeof(struct gfs2_dinode)); 330 sc.sc_total += head->lh_local_total; 331 sc.sc_free += head->lh_local_free; 332 sc.sc_dinodes += head->lh_local_dinodes; 333 gfs2_statfs_change_out(&sc, bh->b_data + sizeof(struct gfs2_dinode)); 334 335 fs_info(sdp, "jid=%u: Updated master statfs Total:%lld, " 336 "Free:%lld, Dinodes:%lld after change " 337 "[%+lld,%+lld,%+lld]\n", jd->jd_jid, sc.sc_total, 338 sc.sc_free, sc.sc_dinodes, head->lh_local_total, 339 head->lh_local_free, head->lh_local_dinodes); 340 } else { /* Zero out the local statfs inode */ 341 memset(bh->b_data + sizeof(struct gfs2_dinode), 0, 342 sizeof(struct gfs2_statfs_change)); 343 /* If it's our own journal, reset any in-memory changes too */ 344 if (jd->jd_jid == sdp->sd_lockstruct.ls_jid) { 345 memset(&sdp->sd_statfs_local, 0, 346 sizeof(struct gfs2_statfs_change_host)); 347 } 348 } 349 spin_unlock(&sdp->sd_statfs_spin); 350 351 mark_buffer_dirty(bh); 352 brelse(bh); 353 gfs2_inode_metasync(ip->i_gl); 354 355 out: 356 return error; 357 } 358 359 /** 360 * recover_local_statfs - Update the master and local statfs changes for this 361 * journal. 362 * 363 * Previously, statfs updates would be read in from the local statfs inode and 364 * synced to the master statfs inode during recovery. 365 * 366 * We now use the statfs updates in the journal head to update the master statfs 367 * inode instead of reading in from the local statfs inode. To preserve backward 368 * compatibility with kernels that can't do this, we still need to keep the 369 * local statfs inode up to date by writing changes to it. At some point in the 370 * future, we can do away with the local statfs inodes altogether and keep the 371 * statfs changes solely in the journal. 372 * 373 * @jd: the journal 374 * @head: the journal head 375 * 376 * Returns: errno 377 */ 378 static void recover_local_statfs(struct gfs2_jdesc *jd, 379 struct gfs2_log_header_host *head) 380 { 381 int error; 382 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 383 384 if (!head->lh_local_total && !head->lh_local_free 385 && !head->lh_local_dinodes) /* No change */ 386 goto zero_local; 387 388 /* First update the master statfs inode with the changes we 389 * found in the journal. */ 390 error = update_statfs_inode(jd, head, sdp->sd_statfs_inode); 391 if (error) 392 goto out; 393 394 zero_local: 395 /* Zero out the local statfs inode so any changes in there 396 * are not re-recovered. */ 397 error = update_statfs_inode(jd, NULL, 398 find_local_statfs_inode(sdp, jd->jd_jid)); 399 out: 400 return; 401 } 402 403 void gfs2_recover_func(struct work_struct *work) 404 { 405 struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work); 406 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 407 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 408 struct gfs2_log_header_host head; 409 struct gfs2_holder j_gh, ji_gh, thaw_gh; 410 ktime_t t_start, t_jlck, t_jhd, t_tlck, t_rep; 411 int ro = 0; 412 unsigned int pass; 413 int error = 0; 414 int jlocked = 0; 415 416 if (gfs2_withdrawn(sdp)) { 417 fs_err(sdp, "jid=%u: Recovery not attempted due to withdraw.\n", 418 jd->jd_jid); 419 goto fail; 420 } 421 t_start = ktime_get(); 422 if (sdp->sd_args.ar_spectator) 423 goto fail; 424 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { 425 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", 426 jd->jd_jid); 427 jlocked = 1; 428 /* Acquire the journal lock so we can do recovery */ 429 430 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops, 431 LM_ST_EXCLUSIVE, 432 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE, 433 &j_gh); 434 switch (error) { 435 case 0: 436 break; 437 438 case GLR_TRYFAILED: 439 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid); 440 error = 0; 441 goto fail; 442 443 default: 444 goto fail; 445 } 446 447 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 448 LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); 449 if (error) 450 goto fail_gunlock_j; 451 } else { 452 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid); 453 } 454 455 t_jlck = ktime_get(); 456 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid); 457 458 error = gfs2_jdesc_check(jd); 459 if (error) 460 goto fail_gunlock_ji; 461 462 error = gfs2_find_jhead(jd, &head, true); 463 if (error) 464 goto fail_gunlock_ji; 465 t_jhd = ktime_get(); 466 fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid, 467 ktime_ms_delta(t_jhd, t_jlck)); 468 469 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 470 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n", 471 jd->jd_jid); 472 473 /* Acquire a shared hold on the freeze lock */ 474 475 error = gfs2_freeze_lock(sdp, &thaw_gh, LM_FLAG_PRIORITY); 476 if (error) 477 goto fail_gunlock_ji; 478 479 if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) { 480 ro = 1; 481 } else if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { 482 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) 483 ro = 1; 484 } else { 485 if (sb_rdonly(sdp->sd_vfs)) { 486 /* check if device itself is read-only */ 487 ro = bdev_read_only(sdp->sd_vfs->s_bdev); 488 if (!ro) { 489 fs_info(sdp, "recovery required on " 490 "read-only filesystem.\n"); 491 fs_info(sdp, "write access will be " 492 "enabled during recovery.\n"); 493 } 494 } 495 } 496 497 if (ro) { 498 fs_warn(sdp, "jid=%u: Can't replay: read-only block " 499 "device\n", jd->jd_jid); 500 error = -EROFS; 501 goto fail_gunlock_thaw; 502 } 503 504 t_tlck = ktime_get(); 505 fs_info(sdp, "jid=%u: Replaying journal...0x%x to 0x%x\n", 506 jd->jd_jid, head.lh_tail, head.lh_blkno); 507 508 /* We take the sd_log_flush_lock here primarily to prevent log 509 * flushes and simultaneous journal replays from stomping on 510 * each other wrt jd_log_bio. */ 511 down_read(&sdp->sd_log_flush_lock); 512 for (pass = 0; pass < 2; pass++) { 513 lops_before_scan(jd, &head, pass); 514 error = foreach_descriptor(jd, head.lh_tail, 515 head.lh_blkno, pass); 516 lops_after_scan(jd, error, pass); 517 if (error) { 518 up_read(&sdp->sd_log_flush_lock); 519 goto fail_gunlock_thaw; 520 } 521 } 522 523 recover_local_statfs(jd, &head); 524 clean_journal(jd, &head); 525 up_read(&sdp->sd_log_flush_lock); 526 527 gfs2_freeze_unlock(&thaw_gh); 528 t_rep = ktime_get(); 529 fs_info(sdp, "jid=%u: Journal replayed in %lldms [jlck:%lldms, " 530 "jhead:%lldms, tlck:%lldms, replay:%lldms]\n", 531 jd->jd_jid, ktime_ms_delta(t_rep, t_start), 532 ktime_ms_delta(t_jlck, t_start), 533 ktime_ms_delta(t_jhd, t_jlck), 534 ktime_ms_delta(t_tlck, t_jhd), 535 ktime_ms_delta(t_rep, t_tlck)); 536 } 537 538 gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS); 539 540 if (jlocked) { 541 gfs2_glock_dq_uninit(&ji_gh); 542 gfs2_glock_dq_uninit(&j_gh); 543 } 544 545 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid); 546 goto done; 547 548 fail_gunlock_thaw: 549 gfs2_freeze_unlock(&thaw_gh); 550 fail_gunlock_ji: 551 if (jlocked) { 552 gfs2_glock_dq_uninit(&ji_gh); 553 fail_gunlock_j: 554 gfs2_glock_dq_uninit(&j_gh); 555 } 556 557 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done"); 558 fail: 559 jd->jd_recover_error = error; 560 gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP); 561 done: 562 clear_bit(JDF_RECOVERY, &jd->jd_flags); 563 smp_mb__after_atomic(); 564 wake_up_bit(&jd->jd_flags, JDF_RECOVERY); 565 } 566 567 int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait) 568 { 569 int rv; 570 571 if (test_and_set_bit(JDF_RECOVERY, &jd->jd_flags)) 572 return -EBUSY; 573 574 /* we have JDF_RECOVERY, queue should always succeed */ 575 rv = queue_work(gfs_recovery_wq, &jd->jd_work); 576 BUG_ON(!rv); 577 578 if (wait) 579 wait_on_bit(&jd->jd_flags, JDF_RECOVERY, 580 TASK_UNINTERRUPTIBLE); 581 582 return wait ? jd->jd_recover_error : 0; 583 } 584 585