1 /* 2 * do_journal.c --- Scribble onto the journal! 3 * 4 * Copyright (C) 2014 Oracle. This file may be redistributed 5 * under the terms of the GNU Public License. 6 */ 7 8 #include "config.h" 9 #include <stdio.h> 10 #ifdef HAVE_GETOPT_H 11 #include <getopt.h> 12 #else 13 extern int optind; 14 extern char *optarg; 15 #endif 16 #include <ctype.h> 17 #include <unistd.h> 18 #ifdef HAVE_SYS_TIME_H 19 #include <sys/time.h> 20 #endif 21 22 #include "debugfs.h" 23 #include "ext2fs/kernel-jbd.h" 24 #include "journal.h" 25 26 #undef DEBUG 27 28 #ifdef DEBUG 29 # define dbg_printf(f, a...) do {printf("JFS DEBUG: " f, ## a); \ 30 fflush(stdout); \ 31 } while (0) 32 #else 33 # define dbg_printf(f, a...) 34 #endif 35 36 #define JOURNAL_CHECK_TRANS_MAGIC(x) \ 37 do { \ 38 if ((x)->magic != J_TRANS_MAGIC) \ 39 return EXT2_ET_INVALID_ARGUMENT; \ 40 } while (0) 41 42 #define J_TRANS_MAGIC 0xD15EA5ED 43 #define J_TRANS_OPEN 1 44 #define J_TRANS_COMMITTED 2 45 struct journal_transaction_s { 46 unsigned int magic; 47 ext2_filsys fs; 48 journal_t *journal; 49 blk64_t block; 50 blk64_t start, end; 51 tid_t tid; 52 int flags; 53 }; 54 55 typedef struct journal_transaction_s journal_transaction_t; 56 57 static journal_t *current_journal = NULL; 58 59 static void journal_dump_trans(journal_transaction_t *trans EXT2FS_ATTR((unused)), 60 const char *tag EXT2FS_ATTR((unused))) 61 { 62 dbg_printf("TRANS %p(%s): tid=%d start=%llu block=%llu end=%llu " 63 "flags=0x%x\n", trans, tag, trans->tid, trans->start, 64 trans->block, trans->end, trans->flags); 65 } 66 67 static errcode_t journal_commit_trans(journal_transaction_t *trans) 68 { 69 struct buffer_head *bh, *cbh = NULL; 70 struct commit_header *commit; 71 #ifdef HAVE_SYS_TIME_H 72 struct timeval tv; 73 #endif 74 errcode_t err; 75 76 JOURNAL_CHECK_TRANS_MAGIC(trans); 77 78 if ((trans->flags & J_TRANS_COMMITTED) || 79 !(trans->flags & J_TRANS_OPEN)) 80 return EXT2_ET_INVALID_ARGUMENT; 81 82 bh = getblk(trans->journal->j_dev, 0, trans->journal->j_blocksize); 83 if (bh == NULL) 84 return ENOMEM; 85 86 /* write the descriptor block header */ 87 commit = (struct commit_header *)bh->b_data; 88 commit->h_magic = ext2fs_cpu_to_be32(JFS_MAGIC_NUMBER); 89 commit->h_blocktype = ext2fs_cpu_to_be32(JFS_COMMIT_BLOCK); 90 commit->h_sequence = ext2fs_cpu_to_be32(trans->tid); 91 if (jfs_has_feature_checksum(trans->journal)) { 92 __u32 csum_v1 = ~0; 93 blk64_t cblk; 94 95 cbh = getblk(trans->journal->j_dev, 0, 96 trans->journal->j_blocksize); 97 if (cbh == NULL) { 98 err = ENOMEM; 99 goto error; 100 } 101 102 for (cblk = trans->start; cblk < trans->block; cblk++) { 103 err = journal_bmap(trans->journal, cblk, 104 &cbh->b_blocknr); 105 if (err) 106 goto error; 107 mark_buffer_uptodate(cbh, 0); 108 ll_rw_block(READ, 1, &cbh); 109 err = cbh->b_err; 110 if (err) 111 goto error; 112 csum_v1 = ext2fs_crc32_be(csum_v1, 113 (unsigned char const *)cbh->b_data, 114 cbh->b_size); 115 } 116 117 commit->h_chksum_type = JFS_CRC32_CHKSUM; 118 commit->h_chksum_size = JFS_CRC32_CHKSUM_SIZE; 119 commit->h_chksum[0] = ext2fs_cpu_to_be32(csum_v1); 120 } else { 121 commit->h_chksum_type = 0; 122 commit->h_chksum_size = 0; 123 commit->h_chksum[0] = 0; 124 } 125 #ifdef HAVE_SYS_TIME_H 126 gettimeofday(&tv, NULL); 127 commit->h_commit_sec = ext2fs_cpu_to_be32(tv.tv_sec); 128 commit->h_commit_nsec = ext2fs_cpu_to_be32(tv.tv_usec * 1000); 129 #else 130 commit->h_commit_sec = 0; 131 commit->h_commit_nsec = 0; 132 #endif 133 134 /* Write block */ 135 jbd2_commit_block_csum_set(trans->journal, bh); 136 err = journal_bmap(trans->journal, trans->block, &bh->b_blocknr); 137 if (err) 138 goto error; 139 140 dbg_printf("Writing commit block at %llu:%llu\n", trans->block, 141 bh->b_blocknr); 142 mark_buffer_dirty(bh); 143 ll_rw_block(WRITE, 1, &bh); 144 err = bh->b_err; 145 if (err) 146 goto error; 147 trans->flags |= J_TRANS_COMMITTED; 148 trans->flags &= ~J_TRANS_OPEN; 149 trans->block++; 150 151 ext2fs_set_feature_journal_needs_recovery(trans->fs->super); 152 ext2fs_mark_super_dirty(trans->fs); 153 error: 154 if (cbh) 155 brelse(cbh); 156 brelse(bh); 157 return err; 158 } 159 160 static errcode_t journal_add_revoke_to_trans(journal_transaction_t *trans, 161 blk64_t *revoke_list, 162 size_t revoke_len) 163 { 164 journal_revoke_header_t *jrb; 165 void *buf; 166 size_t i, offset; 167 blk64_t curr_blk; 168 unsigned int sz; 169 unsigned csum_size = 0; 170 struct buffer_head *bh; 171 errcode_t err; 172 173 JOURNAL_CHECK_TRANS_MAGIC(trans); 174 175 if ((trans->flags & J_TRANS_COMMITTED) || 176 !(trans->flags & J_TRANS_OPEN)) 177 return EXT2_ET_INVALID_ARGUMENT; 178 179 if (revoke_len == 0) 180 return 0; 181 182 /* Do we need to leave space at the end for a checksum? */ 183 if (journal_has_csum_v2or3(trans->journal)) 184 csum_size = sizeof(struct journal_revoke_tail); 185 186 curr_blk = trans->block; 187 188 bh = getblk(trans->journal->j_dev, curr_blk, 189 trans->journal->j_blocksize); 190 if (bh == NULL) 191 return ENOMEM; 192 jrb = buf = bh->b_data; 193 jrb->r_header.h_magic = ext2fs_cpu_to_be32(JFS_MAGIC_NUMBER); 194 jrb->r_header.h_blocktype = ext2fs_cpu_to_be32(JFS_REVOKE_BLOCK); 195 jrb->r_header.h_sequence = ext2fs_cpu_to_be32(trans->tid); 196 offset = sizeof(*jrb); 197 198 if (jfs_has_feature_64bit(trans->journal)) 199 sz = 8; 200 else 201 sz = 4; 202 203 for (i = 0; i < revoke_len; i++) { 204 /* Block full, write to journal */ 205 if (offset + sz > trans->journal->j_blocksize - csum_size) { 206 jrb->r_count = ext2fs_cpu_to_be32(offset); 207 jbd2_revoke_csum_set(trans->journal, bh); 208 209 err = journal_bmap(trans->journal, curr_blk, 210 &bh->b_blocknr); 211 if (err) 212 goto error; 213 dbg_printf("Writing revoke block at %llu:%llu\n", 214 curr_blk, bh->b_blocknr); 215 mark_buffer_dirty(bh); 216 ll_rw_block(WRITE, 1, &bh); 217 err = bh->b_err; 218 if (err) 219 goto error; 220 221 offset = sizeof(*jrb); 222 curr_blk++; 223 } 224 225 if (revoke_list[i] >= 226 ext2fs_blocks_count(trans->journal->j_fs_dev->k_fs->super)) { 227 err = EXT2_ET_BAD_BLOCK_NUM; 228 goto error; 229 } 230 231 if (jfs_has_feature_64bit(trans->journal)) 232 *((__u64 *)(&((char *)buf)[offset])) = 233 ext2fs_cpu_to_be64(revoke_list[i]); 234 else 235 *((__u32 *)(&((char *)buf)[offset])) = 236 ext2fs_cpu_to_be32(revoke_list[i]); 237 offset += sz; 238 } 239 240 if (offset > 0) { 241 jrb->r_count = ext2fs_cpu_to_be32(offset); 242 jbd2_revoke_csum_set(trans->journal, bh); 243 244 err = journal_bmap(trans->journal, curr_blk, &bh->b_blocknr); 245 if (err) 246 goto error; 247 dbg_printf("Writing revoke block at %llu:%llu\n", 248 curr_blk, bh->b_blocknr); 249 mark_buffer_dirty(bh); 250 ll_rw_block(WRITE, 1, &bh); 251 err = bh->b_err; 252 if (err) 253 goto error; 254 curr_blk++; 255 } 256 257 error: 258 trans->block = curr_blk; 259 brelse(bh); 260 return err; 261 } 262 263 static errcode_t journal_add_blocks_to_trans(journal_transaction_t *trans, 264 blk64_t *block_list, size_t block_len, 265 FILE *fp) 266 { 267 blk64_t curr_blk, jdb_blk; 268 size_t i, j; 269 int csum_size = 0; 270 journal_header_t *jdb; 271 journal_block_tag_t *jdbt; 272 int tag_bytes; 273 void *buf = NULL, *jdb_buf = NULL; 274 struct buffer_head *bh = NULL, *data_bh; 275 errcode_t err; 276 277 JOURNAL_CHECK_TRANS_MAGIC(trans); 278 279 if ((trans->flags & J_TRANS_COMMITTED) || 280 !(trans->flags & J_TRANS_OPEN)) 281 return EXT2_ET_INVALID_ARGUMENT; 282 283 if (block_len == 0) 284 return 0; 285 286 /* Do we need to leave space at the end for a checksum? */ 287 if (journal_has_csum_v2or3(trans->journal)) 288 csum_size = sizeof(struct journal_block_tail); 289 290 curr_blk = jdb_blk = trans->block; 291 292 data_bh = getblk(trans->journal->j_dev, curr_blk, 293 trans->journal->j_blocksize); 294 if (data_bh == NULL) 295 return ENOMEM; 296 buf = data_bh->b_data; 297 298 /* write the descriptor block header */ 299 bh = getblk(trans->journal->j_dev, curr_blk, 300 trans->journal->j_blocksize); 301 if (bh == NULL) { 302 err = ENOMEM; 303 goto error; 304 } 305 jdb = jdb_buf = bh->b_data; 306 jdb->h_magic = ext2fs_cpu_to_be32(JFS_MAGIC_NUMBER); 307 jdb->h_blocktype = ext2fs_cpu_to_be32(JFS_DESCRIPTOR_BLOCK); 308 jdb->h_sequence = ext2fs_cpu_to_be32(trans->tid); 309 jdbt = (journal_block_tag_t *)(jdb + 1); 310 311 curr_blk++; 312 for (i = 0; i < block_len; i++) { 313 j = fread(data_bh->b_data, trans->journal->j_blocksize, 1, fp); 314 if (j != 1) { 315 err = errno; 316 goto error; 317 } 318 319 tag_bytes = journal_tag_bytes(trans->journal); 320 321 /* No space left in descriptor block, write it out */ 322 if ((char *)jdbt + tag_bytes > 323 (char *)jdb_buf + trans->journal->j_blocksize - csum_size) { 324 jbd2_descr_block_csum_set(trans->journal, bh); 325 err = journal_bmap(trans->journal, jdb_blk, 326 &bh->b_blocknr); 327 if (err) 328 goto error; 329 dbg_printf("Writing descriptor block at %llu:%llu\n", 330 jdb_blk, bh->b_blocknr); 331 mark_buffer_dirty(bh); 332 ll_rw_block(WRITE, 1, &bh); 333 err = bh->b_err; 334 if (err) 335 goto error; 336 337 jdbt = (journal_block_tag_t *)(jdb + 1); 338 jdb_blk = curr_blk; 339 curr_blk++; 340 } 341 342 if (block_list[i] >= 343 ext2fs_blocks_count(trans->journal->j_fs_dev->k_fs->super)) { 344 err = EXT2_ET_BAD_BLOCK_NUM; 345 goto error; 346 } 347 348 /* Fill out the block tag */ 349 jdbt->t_blocknr = ext2fs_cpu_to_be32(block_list[i] & 0xFFFFFFFF); 350 jdbt->t_flags = 0; 351 if (jdbt != (journal_block_tag_t *)(jdb + 1)) 352 jdbt->t_flags |= ext2fs_cpu_to_be16(JFS_FLAG_SAME_UUID); 353 else { 354 memcpy(jdbt + tag_bytes, 355 trans->journal->j_superblock->s_uuid, 356 sizeof(trans->journal->j_superblock->s_uuid)); 357 tag_bytes += 16; 358 } 359 if (i == block_len - 1) 360 jdbt->t_flags |= ext2fs_cpu_to_be16(JFS_FLAG_LAST_TAG); 361 if (*((__u32 *)buf) == ext2fs_cpu_to_be32(JFS_MAGIC_NUMBER)) { 362 *((__u32 *)buf) = 0; 363 jdbt->t_flags |= ext2fs_cpu_to_be16(JFS_FLAG_ESCAPE); 364 } 365 if (jfs_has_feature_64bit(trans->journal)) 366 jdbt->t_blocknr_high = ext2fs_cpu_to_be32(block_list[i] >> 32); 367 jbd2_block_tag_csum_set(trans->journal, jdbt, data_bh, 368 trans->tid); 369 370 /* Write the data block */ 371 err = journal_bmap(trans->journal, curr_blk, 372 &data_bh->b_blocknr); 373 if (err) 374 goto error; 375 dbg_printf("Writing data block %llu at %llu:%llu tag %d\n", 376 block_list[i], curr_blk, data_bh->b_blocknr, 377 tag_bytes); 378 mark_buffer_dirty(data_bh); 379 ll_rw_block(WRITE, 1, &data_bh); 380 err = data_bh->b_err; 381 if (err) 382 goto error; 383 384 curr_blk++; 385 jdbt = (journal_block_tag_t *)(((char *)jdbt) + tag_bytes); 386 } 387 388 /* Write out the last descriptor block */ 389 if (jdbt != (journal_block_tag_t *)(jdb + 1)) { 390 jbd2_descr_block_csum_set(trans->journal, bh); 391 err = journal_bmap(trans->journal, jdb_blk, &bh->b_blocknr); 392 if (err) 393 goto error; 394 dbg_printf("Writing descriptor block at %llu:%llu\n", 395 jdb_blk, bh->b_blocknr); 396 mark_buffer_dirty(bh); 397 ll_rw_block(WRITE, 1, &bh); 398 err = bh->b_err; 399 if (err) 400 goto error; 401 } 402 403 error: 404 trans->block = curr_blk; 405 if (bh) 406 brelse(bh); 407 brelse(data_bh); 408 return err; 409 } 410 411 static blk64_t journal_guess_blocks(journal_t *journal, blk64_t data_blocks, 412 blk64_t revoke_blocks) 413 { 414 blk64_t ret = 1; 415 unsigned int bs, sz; 416 417 /* Estimate # of revoke blocks */ 418 bs = journal->j_blocksize; 419 if (journal_has_csum_v2or3(journal)) 420 bs -= sizeof(struct journal_revoke_tail); 421 sz = jfs_has_feature_64bit(journal) ? sizeof(__u64) : sizeof(__u32); 422 ret += revoke_blocks * sz / bs; 423 424 /* Estimate # of data blocks */ 425 bs = journal->j_blocksize - 16; 426 if (journal_has_csum_v2or3(journal)) 427 bs -= sizeof(struct journal_block_tail); 428 sz = journal_tag_bytes(journal); 429 ret += data_blocks * sz / bs; 430 431 ret += data_blocks; 432 433 return ret; 434 } 435 436 static errcode_t journal_open_trans(journal_t *journal, 437 journal_transaction_t *trans, 438 blk64_t blocks) 439 { 440 trans->fs = journal->j_fs_dev->k_fs; 441 trans->journal = journal; 442 trans->flags = J_TRANS_OPEN; 443 444 if (journal->j_tail == 0) { 445 /* Clean journal, start at the tail */ 446 trans->tid = journal->j_tail_sequence; 447 trans->start = journal->j_first; 448 } else { 449 /* Put new transaction at the head of the list */ 450 trans->tid = journal->j_transaction_sequence; 451 trans->start = journal->j_head; 452 } 453 454 trans->block = trans->start; 455 if (trans->start + blocks > journal->j_last) 456 return ENOSPC; 457 trans->end = trans->block + blocks; 458 journal_dump_trans(trans, "new transaction"); 459 460 trans->magic = J_TRANS_MAGIC; 461 return 0; 462 } 463 464 static errcode_t journal_close_trans(journal_transaction_t *trans) 465 { 466 journal_t *journal; 467 468 JOURNAL_CHECK_TRANS_MAGIC(trans); 469 470 if (!(trans->flags & J_TRANS_COMMITTED)) 471 return 0; 472 473 journal = trans->journal; 474 if (journal->j_tail == 0) { 475 /* Update the tail */ 476 journal->j_tail_sequence = trans->tid; 477 journal->j_tail = trans->start; 478 journal->j_superblock->s_start = ext2fs_cpu_to_be32(trans->start); 479 } 480 481 /* Update the head */ 482 journal->j_head = trans->end + 1; 483 journal->j_transaction_sequence = trans->tid + 1; 484 485 trans->magic = 0; 486 487 /* Mark ourselves as needing recovery */ 488 if (!ext2fs_has_feature_journal_needs_recovery(trans->fs->super)) { 489 ext2fs_set_feature_journal_needs_recovery(trans->fs->super); 490 ext2fs_mark_super_dirty(trans->fs); 491 } 492 493 return 0; 494 } 495 496 #define JOURNAL_WRITE_NO_COMMIT 1 497 static errcode_t journal_write(journal_t *journal, 498 int flags, blk64_t *block_list, 499 size_t block_len, blk64_t *revoke_list, 500 size_t revoke_len, FILE *fp) 501 { 502 blk64_t blocks; 503 journal_transaction_t trans; 504 errcode_t err; 505 506 if (revoke_len > 0) { 507 jfs_set_feature_revoke(journal); 508 mark_buffer_dirty(journal->j_sb_buffer); 509 } 510 511 blocks = journal_guess_blocks(journal, block_len, revoke_len); 512 err = journal_open_trans(journal, &trans, blocks); 513 if (err) 514 goto error; 515 516 err = journal_add_blocks_to_trans(&trans, block_list, block_len, fp); 517 if (err) 518 goto error; 519 520 err = journal_add_revoke_to_trans(&trans, revoke_list, revoke_len); 521 if (err) 522 goto error; 523 524 if (!(flags & JOURNAL_WRITE_NO_COMMIT)) { 525 err = journal_commit_trans(&trans); 526 if (err) 527 goto error; 528 } 529 530 err = journal_close_trans(&trans); 531 if (err) 532 goto error; 533 error: 534 return err; 535 } 536 537 void do_journal_write(int argc, char *argv[]) 538 { 539 blk64_t *blist = NULL, *rlist = NULL; 540 size_t bn = 0, rn = 0; 541 FILE *fp = NULL; 542 int opt; 543 int flags = 0; 544 errcode_t err; 545 546 if (current_journal == NULL) { 547 printf("Journal not open.\n"); 548 return; 549 } 550 551 reset_getopt(); 552 while ((opt = getopt(argc, argv, "b:r:c")) != -1) { 553 switch (opt) { 554 case 'b': 555 err = read_list(optarg, &blist, &bn); 556 if (err) 557 com_err(argv[0], err, 558 "while reading block list"); 559 break; 560 case 'r': 561 err = read_list(optarg, &rlist, &rn); 562 if (err) 563 com_err(argv[0], err, 564 "while reading revoke list"); 565 break; 566 case 'c': 567 flags |= JOURNAL_WRITE_NO_COMMIT; 568 break; 569 default: 570 printf("%s [-b blocks] [-r revoke] [-c] file\n", 571 argv[0]); 572 printf("-b: Write these blocks into transaction.\n"); 573 printf("-c: Do not commit transaction.\n"); 574 printf("-r: Revoke these blocks from transaction.\n"); 575 576 goto out; 577 } 578 } 579 580 if (bn > 0 && optind != argc - 1) { 581 printf("Need a file to read blocks from.\n"); 582 return; 583 } 584 585 if (bn > 0) { 586 fp = fopen(argv[optind], "r"); 587 if (fp == NULL) { 588 com_err(argv[0], errno, 589 "while opening journal data file"); 590 goto out; 591 } 592 } 593 594 err = journal_write(current_journal, flags, blist, bn, 595 rlist, rn, fp); 596 if (err) 597 com_err("journal_write", err, "while writing journal"); 598 599 if (fp) 600 fclose(fp); 601 out: 602 if (blist) 603 free(blist); 604 if (rlist) 605 free(rlist); 606 } 607 608 /* Make sure we wrap around the log correctly! */ 609 #define wrap(journal, var) \ 610 do { \ 611 if (var >= (journal)->j_last) \ 612 var -= ((journal)->j_last - (journal)->j_first); \ 613 } while (0) 614 615 /* 616 * Count the number of in-use tags in a journal descriptor block. 617 */ 618 619 static int count_tags(journal_t *journal, char *buf) 620 { 621 char *tagp; 622 journal_block_tag_t *tag; 623 int nr = 0, size = journal->j_blocksize; 624 int tag_bytes = journal_tag_bytes(journal); 625 626 if (journal_has_csum_v2or3(journal)) 627 size -= sizeof(struct journal_block_tail); 628 629 tagp = buf + sizeof(journal_header_t); 630 631 while ((tagp - buf + tag_bytes) <= size) { 632 tag = (journal_block_tag_t *) tagp; 633 634 nr++; 635 tagp += tag_bytes; 636 if (!(tag->t_flags & ext2fs_cpu_to_be16(JFS_FLAG_SAME_UUID))) 637 tagp += 16; 638 639 if (tag->t_flags & ext2fs_cpu_to_be16(JFS_FLAG_LAST_TAG)) 640 break; 641 } 642 643 return nr; 644 } 645 646 static errcode_t journal_find_head(journal_t *journal) 647 { 648 unsigned int next_commit_ID; 649 blk64_t next_log_block, head_block; 650 int err; 651 journal_superblock_t *sb; 652 journal_header_t *tmp; 653 struct buffer_head *bh; 654 unsigned int sequence; 655 int blocktype; 656 657 /* 658 * First thing is to establish what we expect to find in the log 659 * (in terms of transaction IDs), and where (in terms of log 660 * block offsets): query the superblock. 661 */ 662 663 sb = journal->j_superblock; 664 next_commit_ID = ext2fs_be32_to_cpu(sb->s_sequence); 665 next_log_block = ext2fs_be32_to_cpu(sb->s_start); 666 head_block = next_log_block; 667 668 if (next_log_block == 0) 669 return 0; 670 671 bh = getblk(journal->j_dev, 0, journal->j_blocksize); 672 if (bh == NULL) 673 return ENOMEM; 674 675 /* 676 * Now we walk through the log, transaction by transaction, 677 * making sure that each transaction has a commit block in the 678 * expected place. Each complete transaction gets replayed back 679 * into the main filesystem. 680 */ 681 while (1) { 682 dbg_printf("Scanning for sequence ID %u at %lu/%lu\n", 683 next_commit_ID, (unsigned long)next_log_block, 684 journal->j_last); 685 686 /* Skip over each chunk of the transaction looking 687 * either the next descriptor block or the final commit 688 * record. */ 689 err = journal_bmap(journal, next_log_block, &bh->b_blocknr); 690 if (err) 691 goto err; 692 mark_buffer_uptodate(bh, 0); 693 ll_rw_block(READ, 1, &bh); 694 err = bh->b_err; 695 if (err) 696 goto err; 697 698 next_log_block++; 699 wrap(journal, next_log_block); 700 701 /* What kind of buffer is it? 702 * 703 * If it is a descriptor block, check that it has the 704 * expected sequence number. Otherwise, we're all done 705 * here. */ 706 707 tmp = (journal_header_t *)bh->b_data; 708 709 if (tmp->h_magic != ext2fs_cpu_to_be32(JFS_MAGIC_NUMBER)) { 710 dbg_printf("JBD2: wrong magic 0x%x\n", tmp->h_magic); 711 goto err; 712 } 713 714 blocktype = ext2fs_be32_to_cpu(tmp->h_blocktype); 715 sequence = ext2fs_be32_to_cpu(tmp->h_sequence); 716 dbg_printf("Found magic %d, sequence %d\n", 717 blocktype, sequence); 718 719 if (sequence != next_commit_ID) { 720 dbg_printf("JBD2: Wrong sequence %d (wanted %d)\n", 721 sequence, next_commit_ID); 722 goto err; 723 } 724 725 /* OK, we have a valid descriptor block which matches 726 * all of the sequence number checks. What are we going 727 * to do with it? That depends on the pass... */ 728 729 switch (blocktype) { 730 case JFS_DESCRIPTOR_BLOCK: 731 next_log_block += count_tags(journal, bh->b_data); 732 wrap(journal, next_log_block); 733 continue; 734 735 case JFS_COMMIT_BLOCK: 736 head_block = next_log_block; 737 next_commit_ID++; 738 continue; 739 740 case JFS_REVOKE_BLOCK: 741 continue; 742 743 default: 744 dbg_printf("Unrecognised magic %d, end of scan.\n", 745 blocktype); 746 err = -EINVAL; 747 goto err; 748 } 749 } 750 751 err: 752 if (err == 0) { 753 dbg_printf("head seq=%d blk=%llu\n", next_commit_ID, 754 head_block); 755 journal->j_transaction_sequence = next_commit_ID; 756 journal->j_head = head_block; 757 } 758 brelse(bh); 759 return err; 760 } 761 762 static void update_journal_csum(journal_t *journal, int ver) 763 { 764 journal_superblock_t *jsb; 765 766 if (journal->j_format_version < 2) 767 return; 768 769 if (journal->j_tail != 0 || 770 ext2fs_has_feature_journal_needs_recovery( 771 journal->j_fs_dev->k_fs->super)) { 772 printf("Journal needs recovery, will not add csums.\n"); 773 return; 774 } 775 776 /* metadata_csum implies journal csum v3 */ 777 jsb = journal->j_superblock; 778 if (ext2fs_has_feature_metadata_csum(journal->j_fs_dev->k_fs->super)) { 779 printf("Setting csum v%d\n", ver); 780 switch (ver) { 781 case 2: 782 jfs_clear_feature_csum3(journal); 783 jfs_set_feature_csum2(journal); 784 jfs_clear_feature_checksum(journal); 785 break; 786 case 3: 787 jfs_set_feature_csum3(journal); 788 jfs_clear_feature_csum2(journal); 789 jfs_clear_feature_checksum(journal); 790 break; 791 default: 792 printf("Unknown checksum v%d\n", ver); 793 break; 794 } 795 journal->j_superblock->s_checksum_type = JBD2_CRC32C_CHKSUM; 796 journal->j_csum_seed = jbd2_chksum(journal, ~0, jsb->s_uuid, 797 sizeof(jsb->s_uuid)); 798 } else { 799 jfs_clear_feature_csum3(journal); 800 jfs_clear_feature_csum2(journal); 801 jfs_set_feature_checksum(journal); 802 } 803 } 804 805 static void update_uuid(journal_t *journal) 806 { 807 size_t z; 808 ext2_filsys fs; 809 810 if (journal->j_format_version < 2) 811 return; 812 813 for (z = 0; z < sizeof(journal->j_superblock->s_uuid); z++) 814 if (journal->j_superblock->s_uuid[z]) 815 break; 816 if (z == 0) 817 return; 818 819 fs = journal->j_fs_dev->k_fs; 820 if (!ext2fs_has_feature_64bit(fs->super)) 821 return; 822 823 if (jfs_has_feature_64bit(journal) && 824 ext2fs_has_feature_64bit(fs->super)) 825 return; 826 827 if (journal->j_tail != 0 || 828 ext2fs_has_feature_journal_needs_recovery(fs->super)) { 829 printf("Journal needs recovery, will not set 64bit.\n"); 830 return; 831 } 832 833 memcpy(journal->j_superblock->s_uuid, fs->super->s_uuid, 834 sizeof(fs->super->s_uuid)); 835 } 836 837 static void update_64bit_flag(journal_t *journal) 838 { 839 if (journal->j_format_version < 2) 840 return; 841 842 if (!ext2fs_has_feature_64bit(journal->j_fs_dev->k_fs->super)) 843 return; 844 845 if (jfs_has_feature_64bit(journal) && 846 ext2fs_has_feature_64bit(journal->j_fs_dev->k_fs->super)) 847 return; 848 849 if (journal->j_tail != 0 || 850 ext2fs_has_feature_journal_needs_recovery( 851 journal->j_fs_dev->k_fs->super)) { 852 printf("Journal needs recovery, will not set 64bit.\n"); 853 return; 854 } 855 856 jfs_set_feature_64bit(journal); 857 } 858 859 void do_journal_open(int argc, char *argv[]) 860 { 861 int opt, enable_csum = 0, csum_ver = 3; 862 journal_t *journal; 863 errcode_t err; 864 865 if (check_fs_open(argv[0])) 866 return; 867 if (check_fs_read_write(argv[0])) 868 return; 869 if (check_fs_bitmaps(argv[0])) 870 return; 871 if (current_journal) { 872 printf("Journal is already open.\n"); 873 return; 874 } 875 if (!ext2fs_has_feature_journal(current_fs->super)) { 876 printf("Journalling is not enabled on this filesystem.\n"); 877 return; 878 } 879 880 reset_getopt(); 881 while ((opt = getopt(argc, argv, "cv:f:")) != -1) { 882 switch (opt) { 883 case 'c': 884 enable_csum = 1; 885 break; 886 case 'f': 887 if (current_fs->journal_name) 888 free(current_fs->journal_name); 889 current_fs->journal_name = strdup(optarg); 890 break; 891 case 'v': 892 csum_ver = atoi(optarg); 893 if (csum_ver != 2 && csum_ver != 3) { 894 printf("Unknown journal csum v%d\n", csum_ver); 895 csum_ver = 3; 896 } 897 break; 898 default: 899 printf("%s: [-c] [-v ver] [-f ext_jnl]\n", argv[0]); 900 printf("-c: Enable journal checksumming.\n"); 901 printf("-v: Use this version checksum format.\n"); 902 printf("-j: Load this external journal.\n"); 903 } 904 } 905 906 err = ext2fs_open_journal(current_fs, ¤t_journal); 907 if (err) { 908 com_err(argv[0], err, "while opening journal"); 909 return; 910 } 911 journal = current_journal; 912 913 dbg_printf("JOURNAL: seq=%d tailseq=%d start=%lu first=%lu " 914 "maxlen=%lu\n", journal->j_tail_sequence, 915 journal->j_transaction_sequence, journal->j_tail, 916 journal->j_first, journal->j_last); 917 918 update_uuid(journal); 919 update_64bit_flag(journal); 920 if (enable_csum) 921 update_journal_csum(journal, csum_ver); 922 923 err = journal_find_head(journal); 924 if (err) 925 com_err(argv[0], err, "while examining journal"); 926 } 927 928 void do_journal_close(int argc EXT2FS_ATTR((unused)), 929 char *argv[] EXT2FS_ATTR((unused))) 930 { 931 if (current_journal == NULL) { 932 printf("Journal not open.\n"); 933 return; 934 } 935 936 ext2fs_close_journal(current_fs, ¤t_journal); 937 } 938 939 void do_journal_run(int argc EXT2FS_ATTR((unused)), char *argv[]) 940 { 941 errcode_t err; 942 943 if (check_fs_open(argv[0])) 944 return; 945 if (check_fs_read_write(argv[0])) 946 return; 947 if (check_fs_bitmaps(argv[0])) 948 return; 949 if (current_journal) { 950 printf("Please close the journal before recovering it.\n"); 951 return; 952 } 953 954 err = ext2fs_run_ext3_journal(¤t_fs); 955 if (err) 956 com_err("journal_run", err, "while recovering journal"); 957 else { 958 ext2fs_clear_feature_journal_needs_recovery(current_fs->super); 959 ext2fs_mark_super_dirty(current_fs); 960 } 961 } 962
