1 /* 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 4 * 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. 8 */ 9 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> 19 20 #include "gfs2.h" 21 #include "incore.h" 22 #include "bmap.h" 23 #include "glock.h" 24 #include "glops.h" 25 #include "log.h" 26 #include "lops.h" 27 #include "meta_io.h" 28 #include "recovery.h" 29 #include "super.h" 30 #include "util.h" 31 #include "dir.h" 32 33 struct workqueue_struct *gfs_recovery_wq; 34 35 int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk, 36 struct buffer_head **bh) 37 { 38 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 39 struct gfs2_glock *gl = ip->i_gl; 40 int new = 0; 41 u64 dblock; 42 u32 extlen; 43 int error; 44 45 error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen); 46 if (error) 47 return error; 48 if (!dblock) { 49 gfs2_consist_inode(ip); 50 return -EIO; 51 } 52 53 *bh = gfs2_meta_ra(gl, dblock, extlen); 54 55 return error; 56 } 57 58 int gfs2_revoke_add(struct gfs2_jdesc *jd, u64 blkno, unsigned int where) 59 { 60 struct list_head *head = &jd->jd_revoke_list; 61 struct gfs2_revoke_replay *rr; 62 int found = 0; 63 64 list_for_each_entry(rr, head, rr_list) { 65 if (rr->rr_blkno == blkno) { 66 found = 1; 67 break; 68 } 69 } 70 71 if (found) { 72 rr->rr_where = where; 73 return 0; 74 } 75 76 rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_NOFS); 77 if (!rr) 78 return -ENOMEM; 79 80 rr->rr_blkno = blkno; 81 rr->rr_where = where; 82 list_add(&rr->rr_list, head); 83 84 return 1; 85 } 86 87 int gfs2_revoke_check(struct gfs2_jdesc *jd, u64 blkno, unsigned int where) 88 { 89 struct gfs2_revoke_replay *rr; 90 int wrap, a, b, revoke; 91 int found = 0; 92 93 list_for_each_entry(rr, &jd->jd_revoke_list, rr_list) { 94 if (rr->rr_blkno == blkno) { 95 found = 1; 96 break; 97 } 98 } 99 100 if (!found) 101 return 0; 102 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); 107 108 return revoke; 109 } 110 111 void gfs2_revoke_clean(struct gfs2_jdesc *jd) 112 { 113 struct list_head *head = &jd->jd_revoke_list; 114 struct gfs2_revoke_replay *rr; 115 116 while (!list_empty(head)) { 117 rr = list_entry(head->next, struct gfs2_revoke_replay, rr_list); 118 list_del(&rr->rr_list); 119 kfree(rr); 120 } 121 } 122 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) 125 { 126 u32 hash, crc; 127 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)) 131 return 1; 132 133 hash = crc32(~0, lh, LH_V1_SIZE - 4); 134 hash = ~crc32_le_shift(hash, 4); /* assume lh_hash is zero */ 135 136 if (be32_to_cpu(lh->lh_hash) != hash) 137 return 1; 138 139 crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4, 140 sdp->sd_sb.sb_bsize - LH_V1_SIZE - 4); 141 142 if ((lh->lh_crc != 0 && be32_to_cpu(lh->lh_crc) != crc)) 143 return 1; 144 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); 149 150 return 0; 151 } 152 /** 153 * get_log_header - read the log header for a given segment 154 * @jd: the journal 155 * @blk: the block to look at 156 * @lh: the log header to return 157 * 158 * Read the log header for a given segement in a given journal. Do a few 159 * sanity checks on it. 160 * 161 * Returns: 0 on success, 162 * 1 if the header was invalid or incomplete, 163 * errno on error 164 */ 165 166 static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk, 167 struct gfs2_log_header_host *head) 168 { 169 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 170 struct buffer_head *bh; 171 int error; 172 173 error = gfs2_replay_read_block(jd, blk, &bh); 174 if (error) 175 return error; 176 177 error = __get_log_header(sdp, (const struct gfs2_log_header *)bh->b_data, 178 blk, head); 179 brelse(bh); 180 181 return error; 182 } 183 184 /** 185 * find_good_lh - find a good log header 186 * @jd: the journal 187 * @blk: the segment to start searching from 188 * @lh: the log header to fill in 189 * @forward: if true search forward in the log, else search backward 190 * 191 * Call get_log_header() to get a log header for a segment, but if the 192 * segment is bad, either scan forward or backward until we find a good one. 193 * 194 * Returns: errno 195 */ 196 197 static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk, 198 struct gfs2_log_header_host *head) 199 { 200 unsigned int orig_blk = *blk; 201 int error; 202 203 for (;;) { 204 error = get_log_header(jd, *blk, head); 205 if (error <= 0) 206 return error; 207 208 if (++*blk == jd->jd_blocks) 209 *blk = 0; 210 211 if (*blk == orig_blk) { 212 gfs2_consist_inode(GFS2_I(jd->jd_inode)); 213 return -EIO; 214 } 215 } 216 } 217 218 /** 219 * jhead_scan - make sure we've found the head of the log 220 * @jd: the journal 221 * @head: this is filled in with the log descriptor of the head 222 * 223 * At this point, seg and lh should be either the head of the log or just 224 * before. Scan forward until we find the head. 225 * 226 * Returns: errno 227 */ 228 229 static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head) 230 { 231 unsigned int blk = head->lh_blkno; 232 struct gfs2_log_header_host lh; 233 int error; 234 235 for (;;) { 236 if (++blk == jd->jd_blocks) 237 blk = 0; 238 239 error = get_log_header(jd, blk, &lh); 240 if (error < 0) 241 return error; 242 if (error == 1) 243 continue; 244 245 if (lh.lh_sequence == head->lh_sequence) { 246 gfs2_consist_inode(GFS2_I(jd->jd_inode)); 247 return -EIO; 248 } 249 if (lh.lh_sequence < head->lh_sequence) 250 break; 251 252 *head = lh; 253 } 254 255 return 0; 256 } 257 258 /** 259 * gfs2_find_jhead - find the head of a log 260 * @jd: the journal 261 * @head: the log descriptor for the head of the log is returned here 262 * 263 * Do a binary search of a journal and find the valid log entry with the 264 * highest sequence number. (i.e. the log head) 265 * 266 * Returns: errno 267 */ 268 269 int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head) 270 { 271 struct gfs2_log_header_host lh_1, lh_m; 272 u32 blk_1, blk_2, blk_m; 273 int error; 274 275 blk_1 = 0; 276 blk_2 = jd->jd_blocks - 1; 277 278 for (;;) { 279 blk_m = (blk_1 + blk_2) / 2; 280 281 error = find_good_lh(jd, &blk_1, &lh_1); 282 if (error) 283 return error; 284 285 error = find_good_lh(jd, &blk_m, &lh_m); 286 if (error) 287 return error; 288 289 if (blk_1 == blk_m || blk_m == blk_2) 290 break; 291 292 if (lh_1.lh_sequence <= lh_m.lh_sequence) 293 blk_1 = blk_m; 294 else 295 blk_2 = blk_m; 296 } 297 298 error = jhead_scan(jd, &lh_1); 299 if (error) 300 return error; 301 302 *head = lh_1; 303 304 return error; 305 } 306 307 /** 308 * foreach_descriptor - go through the active part of the log 309 * @jd: the journal 310 * @start: the first log header in the active region 311 * @end: the last log header (don't process the contents of this entry)) 312 * 313 * Call a given function once for every log descriptor in the active 314 * portion of the log. 315 * 316 * Returns: errno 317 */ 318 319 static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start, 320 unsigned int end, int pass) 321 { 322 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 323 struct buffer_head *bh; 324 struct gfs2_log_descriptor *ld; 325 int error = 0; 326 u32 length; 327 __be64 *ptr; 328 unsigned int offset = sizeof(struct gfs2_log_descriptor); 329 offset += sizeof(__be64) - 1; 330 offset &= ~(sizeof(__be64) - 1); 331 332 while (start != end) { 333 error = gfs2_replay_read_block(jd, start, &bh); 334 if (error) 335 return error; 336 if (gfs2_meta_check(sdp, bh)) { 337 brelse(bh); 338 return -EIO; 339 } 340 ld = (struct gfs2_log_descriptor *)bh->b_data; 341 length = be32_to_cpu(ld->ld_length); 342 343 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) { 344 struct gfs2_log_header_host lh; 345 error = get_log_header(jd, start, &lh); 346 if (!error) { 347 gfs2_replay_incr_blk(jd, &start); 348 brelse(bh); 349 continue; 350 } 351 if (error == 1) { 352 gfs2_consist_inode(GFS2_I(jd->jd_inode)); 353 error = -EIO; 354 } 355 brelse(bh); 356 return error; 357 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) { 358 brelse(bh); 359 return -EIO; 360 } 361 ptr = (__be64 *)(bh->b_data + offset); 362 error = lops_scan_elements(jd, start, ld, ptr, pass); 363 if (error) { 364 brelse(bh); 365 return error; 366 } 367 368 while (length--) 369 gfs2_replay_incr_blk(jd, &start); 370 371 brelse(bh); 372 } 373 374 return 0; 375 } 376 377 /** 378 * clean_journal - mark a dirty journal as being clean 379 * @jd: the journal 380 * @head: the head journal to start from 381 * 382 * Returns: errno 383 */ 384 385 static void clean_journal(struct gfs2_jdesc *jd, 386 struct gfs2_log_header_host *head) 387 { 388 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 389 390 sdp->sd_log_flush_head = head->lh_blkno; 391 gfs2_replay_incr_blk(jd, &sdp->sd_log_flush_head); 392 gfs2_write_log_header(sdp, jd, head->lh_sequence + 1, 0, 393 GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY, 394 REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC); 395 } 396 397 398 static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, 399 unsigned int message) 400 { 401 char env_jid[20]; 402 char env_status[20]; 403 char *envp[] = { env_jid, env_status, NULL }; 404 struct lm_lockstruct *ls = &sdp->sd_lockstruct; 405 406 ls->ls_recover_jid_done = jid; 407 ls->ls_recover_jid_status = message; 408 sprintf(env_jid, "JID=%u", jid); 409 sprintf(env_status, "RECOVERY=%s", 410 message == LM_RD_SUCCESS ? "Done" : "Failed"); 411 kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp); 412 413 if (sdp->sd_lockstruct.ls_ops->lm_recovery_result) 414 sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message); 415 } 416 417 void gfs2_recover_func(struct work_struct *work) 418 { 419 struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work); 420 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 421 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 422 struct gfs2_log_header_host head; 423 struct gfs2_holder j_gh, ji_gh, thaw_gh; 424 ktime_t t_start, t_jlck, t_jhd, t_tlck, t_rep; 425 int ro = 0; 426 unsigned int pass; 427 int error = 0; 428 int jlocked = 0; 429 430 t_start = ktime_get(); 431 if (sdp->sd_args.ar_spectator) 432 goto fail; 433 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { 434 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", 435 jd->jd_jid); 436 jlocked = 1; 437 /* Acquire the journal lock so we can do recovery */ 438 439 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops, 440 LM_ST_EXCLUSIVE, 441 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE, 442 &j_gh); 443 switch (error) { 444 case 0: 445 break; 446 447 case GLR_TRYFAILED: 448 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid); 449 error = 0; 450 451 default: 452 goto fail; 453 }; 454 455 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 456 LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); 457 if (error) 458 goto fail_gunlock_j; 459 } else { 460 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid); 461 } 462 463 t_jlck = ktime_get(); 464 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid); 465 466 error = gfs2_jdesc_check(jd); 467 if (error) 468 goto fail_gunlock_ji; 469 470 error = gfs2_find_jhead(jd, &head); 471 if (error) 472 goto fail_gunlock_ji; 473 t_jhd = ktime_get(); 474 fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid, 475 ktime_ms_delta(t_jhd, t_jlck)); 476 477 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 478 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n", 479 jd->jd_jid); 480 481 /* Acquire a shared hold on the freeze lock */ 482 483 error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 484 LM_FLAG_NOEXP | LM_FLAG_PRIORITY, 485 &thaw_gh); 486 if (error) 487 goto fail_gunlock_ji; 488 489 if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) { 490 ro = 1; 491 } else if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { 492 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) 493 ro = 1; 494 } else { 495 if (sb_rdonly(sdp->sd_vfs)) { 496 /* check if device itself is read-only */ 497 ro = bdev_read_only(sdp->sd_vfs->s_bdev); 498 if (!ro) { 499 fs_info(sdp, "recovery required on " 500 "read-only filesystem.\n"); 501 fs_info(sdp, "write access will be " 502 "enabled during recovery.\n"); 503 } 504 } 505 } 506 507 if (ro) { 508 fs_warn(sdp, "jid=%u: Can't replay: read-only block " 509 "device\n", jd->jd_jid); 510 error = -EROFS; 511 goto fail_gunlock_thaw; 512 } 513 514 t_tlck = ktime_get(); 515 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid); 516 517 for (pass = 0; pass < 2; pass++) { 518 lops_before_scan(jd, &head, pass); 519 error = foreach_descriptor(jd, head.lh_tail, 520 head.lh_blkno, pass); 521 lops_after_scan(jd, error, pass); 522 if (error) 523 goto fail_gunlock_thaw; 524 } 525 526 clean_journal(jd, &head); 527 528 gfs2_glock_dq_uninit(&thaw_gh); 529 t_rep = ktime_get(); 530 fs_info(sdp, "jid=%u: Journal replayed in %lldms [jlck:%lldms, " 531 "jhead:%lldms, tlck:%lldms, replay:%lldms]\n", 532 jd->jd_jid, ktime_ms_delta(t_rep, t_start), 533 ktime_ms_delta(t_jlck, t_start), 534 ktime_ms_delta(t_jhd, t_jlck), 535 ktime_ms_delta(t_tlck, t_jhd), 536 ktime_ms_delta(t_rep, t_tlck)); 537 } 538 539 gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS); 540 541 if (jlocked) { 542 gfs2_glock_dq_uninit(&ji_gh); 543 gfs2_glock_dq_uninit(&j_gh); 544 } 545 546 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid); 547 goto done; 548 549 fail_gunlock_thaw: 550 gfs2_glock_dq_uninit(&thaw_gh); 551 fail_gunlock_ji: 552 if (jlocked) { 553 gfs2_glock_dq_uninit(&ji_gh); 554 fail_gunlock_j: 555 gfs2_glock_dq_uninit(&j_gh); 556 } 557 558 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done"); 559 fail: 560 jd->jd_recover_error = error; 561 gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP); 562 done: 563 clear_bit(JDF_RECOVERY, &jd->jd_flags); 564 smp_mb__after_atomic(); 565 wake_up_bit(&jd->jd_flags, JDF_RECOVERY); 566 } 567 568 int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait) 569 { 570 int rv; 571 572 if (test_and_set_bit(JDF_RECOVERY, &jd->jd_flags)) 573 return -EBUSY; 574 575 /* we have JDF_RECOVERY, queue should always succeed */ 576 rv = queue_work(gfs_recovery_wq, &jd->jd_work); 577 BUG_ON(!rv); 578 579 if (wait) 580 wait_on_bit(&jd->jd_flags, JDF_RECOVERY, 581 TASK_UNINTERRUPTIBLE); 582 583 return wait ? jd->jd_recover_error : 0; 584 } 585 586