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/slab.h> 11 #include <linux/spinlock.h> 12 #include <linux/completion.h> 13 #include <linux/buffer_head.h> 14 #include <linux/gfs2_ondisk.h> 15 #include <linux/crc32.h> 16 #include <linux/lm_interface.h> 17 18 #include "gfs2.h" 19 #include "incore.h" 20 #include "bmap.h" 21 #include "glock.h" 22 #include "glops.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 int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk, 31 struct buffer_head **bh) 32 { 33 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 34 struct gfs2_glock *gl = ip->i_gl; 35 int new = 0; 36 u64 dblock; 37 u32 extlen; 38 int error; 39 40 error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen); 41 if (error) 42 return error; 43 if (!dblock) { 44 gfs2_consist_inode(ip); 45 return -EIO; 46 } 47 48 *bh = gfs2_meta_ra(gl, dblock, extlen); 49 50 return error; 51 } 52 53 int gfs2_revoke_add(struct gfs2_sbd *sdp, u64 blkno, unsigned int where) 54 { 55 struct list_head *head = &sdp->sd_revoke_list; 56 struct gfs2_revoke_replay *rr; 57 int found = 0; 58 59 list_for_each_entry(rr, head, rr_list) { 60 if (rr->rr_blkno == blkno) { 61 found = 1; 62 break; 63 } 64 } 65 66 if (found) { 67 rr->rr_where = where; 68 return 0; 69 } 70 71 rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_NOFS); 72 if (!rr) 73 return -ENOMEM; 74 75 rr->rr_blkno = blkno; 76 rr->rr_where = where; 77 list_add(&rr->rr_list, head); 78 79 return 1; 80 } 81 82 int gfs2_revoke_check(struct gfs2_sbd *sdp, u64 blkno, unsigned int where) 83 { 84 struct gfs2_revoke_replay *rr; 85 int wrap, a, b, revoke; 86 int found = 0; 87 88 list_for_each_entry(rr, &sdp->sd_revoke_list, rr_list) { 89 if (rr->rr_blkno == blkno) { 90 found = 1; 91 break; 92 } 93 } 94 95 if (!found) 96 return 0; 97 98 wrap = (rr->rr_where < sdp->sd_replay_tail); 99 a = (sdp->sd_replay_tail < where); 100 b = (where < rr->rr_where); 101 revoke = (wrap) ? (a || b) : (a && b); 102 103 return revoke; 104 } 105 106 void gfs2_revoke_clean(struct gfs2_sbd *sdp) 107 { 108 struct list_head *head = &sdp->sd_revoke_list; 109 struct gfs2_revoke_replay *rr; 110 111 while (!list_empty(head)) { 112 rr = list_entry(head->next, struct gfs2_revoke_replay, rr_list); 113 list_del(&rr->rr_list); 114 kfree(rr); 115 } 116 } 117 118 static int gfs2_log_header_in(struct gfs2_log_header_host *lh, const void *buf) 119 { 120 const struct gfs2_log_header *str = buf; 121 122 if (str->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) || 123 str->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH)) 124 return 1; 125 126 lh->lh_sequence = be64_to_cpu(str->lh_sequence); 127 lh->lh_flags = be32_to_cpu(str->lh_flags); 128 lh->lh_tail = be32_to_cpu(str->lh_tail); 129 lh->lh_blkno = be32_to_cpu(str->lh_blkno); 130 lh->lh_hash = be32_to_cpu(str->lh_hash); 131 return 0; 132 } 133 134 /** 135 * get_log_header - read the log header for a given segment 136 * @jd: the journal 137 * @blk: the block to look at 138 * @lh: the log header to return 139 * 140 * Read the log header for a given segement in a given journal. Do a few 141 * sanity checks on it. 142 * 143 * Returns: 0 on success, 144 * 1 if the header was invalid or incomplete, 145 * errno on error 146 */ 147 148 static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk, 149 struct gfs2_log_header_host *head) 150 { 151 struct buffer_head *bh; 152 struct gfs2_log_header_host uninitialized_var(lh); 153 const u32 nothing = 0; 154 u32 hash; 155 int error; 156 157 error = gfs2_replay_read_block(jd, blk, &bh); 158 if (error) 159 return error; 160 161 hash = crc32_le((u32)~0, bh->b_data, sizeof(struct gfs2_log_header) - 162 sizeof(u32)); 163 hash = crc32_le(hash, (unsigned char const *)¬hing, sizeof(nothing)); 164 hash ^= (u32)~0; 165 error = gfs2_log_header_in(&lh, bh->b_data); 166 brelse(bh); 167 168 if (error || lh.lh_blkno != blk || lh.lh_hash != hash) 169 return 1; 170 171 *head = lh; 172 173 return 0; 174 } 175 176 /** 177 * find_good_lh - find a good log header 178 * @jd: the journal 179 * @blk: the segment to start searching from 180 * @lh: the log header to fill in 181 * @forward: if true search forward in the log, else search backward 182 * 183 * Call get_log_header() to get a log header for a segment, but if the 184 * segment is bad, either scan forward or backward until we find a good one. 185 * 186 * Returns: errno 187 */ 188 189 static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk, 190 struct gfs2_log_header_host *head) 191 { 192 unsigned int orig_blk = *blk; 193 int error; 194 195 for (;;) { 196 error = get_log_header(jd, *blk, head); 197 if (error <= 0) 198 return error; 199 200 if (++*blk == jd->jd_blocks) 201 *blk = 0; 202 203 if (*blk == orig_blk) { 204 gfs2_consist_inode(GFS2_I(jd->jd_inode)); 205 return -EIO; 206 } 207 } 208 } 209 210 /** 211 * jhead_scan - make sure we've found the head of the log 212 * @jd: the journal 213 * @head: this is filled in with the log descriptor of the head 214 * 215 * At this point, seg and lh should be either the head of the log or just 216 * before. Scan forward until we find the head. 217 * 218 * Returns: errno 219 */ 220 221 static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head) 222 { 223 unsigned int blk = head->lh_blkno; 224 struct gfs2_log_header_host lh; 225 int error; 226 227 for (;;) { 228 if (++blk == jd->jd_blocks) 229 blk = 0; 230 231 error = get_log_header(jd, blk, &lh); 232 if (error < 0) 233 return error; 234 if (error == 1) 235 continue; 236 237 if (lh.lh_sequence == head->lh_sequence) { 238 gfs2_consist_inode(GFS2_I(jd->jd_inode)); 239 return -EIO; 240 } 241 if (lh.lh_sequence < head->lh_sequence) 242 break; 243 244 *head = lh; 245 } 246 247 return 0; 248 } 249 250 /** 251 * gfs2_find_jhead - find the head of a log 252 * @jd: the journal 253 * @head: the log descriptor for the head of the log is returned here 254 * 255 * Do a binary search of a journal and find the valid log entry with the 256 * highest sequence number. (i.e. the log head) 257 * 258 * Returns: errno 259 */ 260 261 int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head) 262 { 263 struct gfs2_log_header_host lh_1, lh_m; 264 u32 blk_1, blk_2, blk_m; 265 int error; 266 267 blk_1 = 0; 268 blk_2 = jd->jd_blocks - 1; 269 270 for (;;) { 271 blk_m = (blk_1 + blk_2) / 2; 272 273 error = find_good_lh(jd, &blk_1, &lh_1); 274 if (error) 275 return error; 276 277 error = find_good_lh(jd, &blk_m, &lh_m); 278 if (error) 279 return error; 280 281 if (blk_1 == blk_m || blk_m == blk_2) 282 break; 283 284 if (lh_1.lh_sequence <= lh_m.lh_sequence) 285 blk_1 = blk_m; 286 else 287 blk_2 = blk_m; 288 } 289 290 error = jhead_scan(jd, &lh_1); 291 if (error) 292 return error; 293 294 *head = lh_1; 295 296 return error; 297 } 298 299 /** 300 * foreach_descriptor - go through the active part of the log 301 * @jd: the journal 302 * @start: the first log header in the active region 303 * @end: the last log header (don't process the contents of this entry)) 304 * 305 * Call a given function once for every log descriptor in the active 306 * portion of the log. 307 * 308 * Returns: errno 309 */ 310 311 static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start, 312 unsigned int end, int pass) 313 { 314 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 315 struct buffer_head *bh; 316 struct gfs2_log_descriptor *ld; 317 int error = 0; 318 u32 length; 319 __be64 *ptr; 320 unsigned int offset = sizeof(struct gfs2_log_descriptor); 321 offset += sizeof(__be64) - 1; 322 offset &= ~(sizeof(__be64) - 1); 323 324 while (start != end) { 325 error = gfs2_replay_read_block(jd, start, &bh); 326 if (error) 327 return error; 328 if (gfs2_meta_check(sdp, bh)) { 329 brelse(bh); 330 return -EIO; 331 } 332 ld = (struct gfs2_log_descriptor *)bh->b_data; 333 length = be32_to_cpu(ld->ld_length); 334 335 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) { 336 struct gfs2_log_header_host lh; 337 error = get_log_header(jd, start, &lh); 338 if (!error) { 339 gfs2_replay_incr_blk(sdp, &start); 340 brelse(bh); 341 continue; 342 } 343 if (error == 1) { 344 gfs2_consist_inode(GFS2_I(jd->jd_inode)); 345 error = -EIO; 346 } 347 brelse(bh); 348 return error; 349 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) { 350 brelse(bh); 351 return -EIO; 352 } 353 ptr = (__be64 *)(bh->b_data + offset); 354 error = lops_scan_elements(jd, start, ld, ptr, pass); 355 if (error) { 356 brelse(bh); 357 return error; 358 } 359 360 while (length--) 361 gfs2_replay_incr_blk(sdp, &start); 362 363 brelse(bh); 364 } 365 366 return 0; 367 } 368 369 /** 370 * clean_journal - mark a dirty journal as being clean 371 * @sdp: the filesystem 372 * @jd: the journal 373 * @gl: the journal's glock 374 * @head: the head journal to start from 375 * 376 * Returns: errno 377 */ 378 379 static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head) 380 { 381 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 382 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 383 unsigned int lblock; 384 struct gfs2_log_header *lh; 385 u32 hash; 386 struct buffer_head *bh; 387 int error; 388 struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 }; 389 390 lblock = head->lh_blkno; 391 gfs2_replay_incr_blk(sdp, &lblock); 392 bh_map.b_size = 1 << ip->i_inode.i_blkbits; 393 error = gfs2_block_map(&ip->i_inode, lblock, &bh_map, 0); 394 if (error) 395 return error; 396 if (!bh_map.b_blocknr) { 397 gfs2_consist_inode(ip); 398 return -EIO; 399 } 400 401 bh = sb_getblk(sdp->sd_vfs, bh_map.b_blocknr); 402 lock_buffer(bh); 403 memset(bh->b_data, 0, bh->b_size); 404 set_buffer_uptodate(bh); 405 clear_buffer_dirty(bh); 406 unlock_buffer(bh); 407 408 lh = (struct gfs2_log_header *)bh->b_data; 409 memset(lh, 0, sizeof(struct gfs2_log_header)); 410 lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 411 lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); 412 lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); 413 lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1); 414 lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT); 415 lh->lh_blkno = cpu_to_be32(lblock); 416 hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header)); 417 lh->lh_hash = cpu_to_be32(hash); 418 419 set_buffer_dirty(bh); 420 if (sync_dirty_buffer(bh)) 421 gfs2_io_error_bh(sdp, bh); 422 brelse(bh); 423 424 return error; 425 } 426 427 428 static void gfs2_lm_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, 429 unsigned int message) 430 { 431 if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) 432 sdp->sd_lockstruct.ls_ops->lm_recovery_done( 433 sdp->sd_lockstruct.ls_lockspace, jid, message); 434 } 435 436 437 /** 438 * gfs2_recover_journal - recovery a given journal 439 * @jd: the struct gfs2_jdesc describing the journal 440 * 441 * Acquire the journal's lock, check to see if the journal is clean, and 442 * do recovery if necessary. 443 * 444 * Returns: errno 445 */ 446 447 int gfs2_recover_journal(struct gfs2_jdesc *jd) 448 { 449 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 450 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 451 struct gfs2_log_header_host head; 452 struct gfs2_holder j_gh, ji_gh, t_gh; 453 unsigned long t; 454 int ro = 0; 455 unsigned int pass; 456 int error; 457 458 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { 459 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", 460 jd->jd_jid); 461 462 /* Acquire the journal lock so we can do recovery */ 463 464 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops, 465 LM_ST_EXCLUSIVE, 466 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE, 467 &j_gh); 468 switch (error) { 469 case 0: 470 break; 471 472 case GLR_TRYFAILED: 473 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid); 474 error = 0; 475 476 default: 477 goto fail; 478 }; 479 480 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 481 LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); 482 if (error) 483 goto fail_gunlock_j; 484 } else { 485 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid); 486 } 487 488 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid); 489 490 error = gfs2_jdesc_check(jd); 491 if (error) 492 goto fail_gunlock_ji; 493 494 error = gfs2_find_jhead(jd, &head); 495 if (error) 496 goto fail_gunlock_ji; 497 498 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 499 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n", 500 jd->jd_jid); 501 502 t = jiffies; 503 504 /* Acquire a shared hold on the transaction lock */ 505 506 error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, 507 LM_FLAG_NOEXP | LM_FLAG_PRIORITY | 508 GL_NOCANCEL | GL_NOCACHE, &t_gh); 509 if (error) 510 goto fail_gunlock_ji; 511 512 if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { 513 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) 514 ro = 1; 515 } else { 516 if (sdp->sd_vfs->s_flags & MS_RDONLY) { 517 /* check if device itself is read-only */ 518 ro = bdev_read_only(sdp->sd_vfs->s_bdev); 519 if (!ro) { 520 fs_info(sdp, "recovery required on " 521 "read-only filesystem.\n"); 522 fs_info(sdp, "write access will be " 523 "enabled during recovery.\n"); 524 } 525 } 526 } 527 528 if (ro) { 529 fs_warn(sdp, "jid=%u: Can't replay: read-only block " 530 "device\n", jd->jd_jid); 531 error = -EROFS; 532 goto fail_gunlock_tr; 533 } 534 535 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid); 536 537 for (pass = 0; pass < 2; pass++) { 538 lops_before_scan(jd, &head, pass); 539 error = foreach_descriptor(jd, head.lh_tail, 540 head.lh_blkno, pass); 541 lops_after_scan(jd, error, pass); 542 if (error) 543 goto fail_gunlock_tr; 544 } 545 546 error = clean_journal(jd, &head); 547 if (error) 548 goto fail_gunlock_tr; 549 550 gfs2_glock_dq_uninit(&t_gh); 551 t = DIV_ROUND_UP(jiffies - t, HZ); 552 fs_info(sdp, "jid=%u: Journal replayed in %lus\n", 553 jd->jd_jid, t); 554 } 555 556 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) 557 gfs2_glock_dq_uninit(&ji_gh); 558 559 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS); 560 561 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) 562 gfs2_glock_dq_uninit(&j_gh); 563 564 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid); 565 return 0; 566 567 fail_gunlock_tr: 568 gfs2_glock_dq_uninit(&t_gh); 569 fail_gunlock_ji: 570 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { 571 gfs2_glock_dq_uninit(&ji_gh); 572 fail_gunlock_j: 573 gfs2_glock_dq_uninit(&j_gh); 574 } 575 576 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done"); 577 578 fail: 579 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP); 580 return error; 581 } 582 583 /** 584 * gfs2_check_journals - Recover any dirty journals 585 * @sdp: the filesystem 586 * 587 */ 588 589 void gfs2_check_journals(struct gfs2_sbd *sdp) 590 { 591 struct gfs2_jdesc *jd; 592 593 for (;;) { 594 jd = gfs2_jdesc_find_dirty(sdp); 595 if (!jd) 596 break; 597 598 if (jd != sdp->sd_jdesc) 599 gfs2_recover_journal(jd); 600 } 601 } 602 603