1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2011 - 2012 Samsung Electronics 4 * EXT4 filesystem implementation in Uboot by 5 * Uma Shankar <uma.shankar@samsung.com> 6 * Manjunatha C Achar <a.manjunatha@samsung.com> 7 * 8 * Journal data structures and headers for Journaling feature of ext4 9 * have been referred from JBD2 (Journaling Block device 2) 10 * implementation in Linux Kernel. 11 * Written by Stephen C. Tweedie <sct@redhat.com> 12 * 13 * Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved 14 */ 15 16 #include <common.h> 17 #include <ext4fs.h> 18 #include <malloc.h> 19 #include <ext_common.h> 20 #include "ext4_common.h" 21 22 static struct revoke_blk_list *revk_blk_list; 23 static struct revoke_blk_list *prev_node; 24 static int first_node = true; 25 26 int gindex; 27 int gd_index; 28 int jrnl_blk_idx; 29 struct journal_log *journal_ptr[MAX_JOURNAL_ENTRIES]; 30 struct dirty_blocks *dirty_block_ptr[MAX_JOURNAL_ENTRIES]; 31 32 int ext4fs_init_journal(void) 33 { 34 int i; 35 char *temp = NULL; 36 struct ext_filesystem *fs = get_fs(); 37 38 /* init globals */ 39 revk_blk_list = NULL; 40 prev_node = NULL; 41 gindex = 0; 42 gd_index = 0; 43 jrnl_blk_idx = 1; 44 45 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { 46 journal_ptr[i] = zalloc(sizeof(struct journal_log)); 47 if (!journal_ptr[i]) 48 goto fail; 49 dirty_block_ptr[i] = zalloc(sizeof(struct dirty_blocks)); 50 if (!dirty_block_ptr[i]) 51 goto fail; 52 journal_ptr[i]->buf = NULL; 53 journal_ptr[i]->blknr = -1; 54 55 dirty_block_ptr[i]->buf = NULL; 56 dirty_block_ptr[i]->blknr = -1; 57 } 58 59 if (fs->blksz == 4096) { 60 temp = zalloc(fs->blksz); 61 if (!temp) 62 goto fail; 63 journal_ptr[gindex]->buf = zalloc(fs->blksz); 64 if (!journal_ptr[gindex]->buf) 65 goto fail; 66 ext4fs_devread(0, 0, fs->blksz, temp); 67 memcpy(temp + SUPERBLOCK_SIZE, fs->sb, SUPERBLOCK_SIZE); 68 memcpy(journal_ptr[gindex]->buf, temp, fs->blksz); 69 journal_ptr[gindex++]->blknr = 0; 70 free(temp); 71 } else { 72 journal_ptr[gindex]->buf = zalloc(fs->blksz); 73 if (!journal_ptr[gindex]->buf) 74 goto fail; 75 memcpy(journal_ptr[gindex]->buf, fs->sb, SUPERBLOCK_SIZE); 76 journal_ptr[gindex++]->blknr = 1; 77 } 78 79 /* Check the file system state using journal super block */ 80 if (ext4fs_check_journal_state(SCAN)) 81 goto fail; 82 /* Check the file system state using journal super block */ 83 if (ext4fs_check_journal_state(RECOVER)) 84 goto fail; 85 86 return 0; 87 fail: 88 return -1; 89 } 90 91 void ext4fs_dump_metadata(void) 92 { 93 struct ext_filesystem *fs = get_fs(); 94 int i; 95 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { 96 if (dirty_block_ptr[i]->blknr == -1) 97 break; 98 put_ext4((uint64_t) ((uint64_t)dirty_block_ptr[i]->blknr * 99 (uint64_t)fs->blksz), dirty_block_ptr[i]->buf, 100 fs->blksz); 101 } 102 } 103 104 void ext4fs_free_journal(void) 105 { 106 int i; 107 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { 108 if (dirty_block_ptr[i]->blknr == -1) 109 break; 110 if (dirty_block_ptr[i]->buf) 111 free(dirty_block_ptr[i]->buf); 112 } 113 114 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { 115 if (journal_ptr[i]->blknr == -1) 116 break; 117 if (journal_ptr[i]->buf) 118 free(journal_ptr[i]->buf); 119 } 120 121 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { 122 if (journal_ptr[i]) 123 free(journal_ptr[i]); 124 if (dirty_block_ptr[i]) 125 free(dirty_block_ptr[i]); 126 } 127 gindex = 0; 128 gd_index = 0; 129 jrnl_blk_idx = 1; 130 } 131 132 int ext4fs_log_gdt(char *gd_table) 133 { 134 struct ext_filesystem *fs = get_fs(); 135 short i; 136 long int var = fs->gdtable_blkno; 137 for (i = 0; i < fs->no_blk_pergdt; i++) { 138 journal_ptr[gindex]->buf = zalloc(fs->blksz); 139 if (!journal_ptr[gindex]->buf) 140 return -ENOMEM; 141 memcpy(journal_ptr[gindex]->buf, gd_table, fs->blksz); 142 gd_table += fs->blksz; 143 journal_ptr[gindex++]->blknr = var++; 144 } 145 146 return 0; 147 } 148 149 /* 150 * This function stores the backup copy of meta data in RAM 151 * journal_buffer -- Buffer containing meta data 152 * blknr -- Block number on disk of the meta data buffer 153 */ 154 int ext4fs_log_journal(char *journal_buffer, uint32_t blknr) 155 { 156 struct ext_filesystem *fs = get_fs(); 157 short i; 158 159 if (!journal_buffer) { 160 printf("Invalid input arguments %s\n", __func__); 161 return -EINVAL; 162 } 163 164 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { 165 if (journal_ptr[i]->blknr == -1) 166 break; 167 if (journal_ptr[i]->blknr == blknr) 168 return 0; 169 } 170 171 journal_ptr[gindex]->buf = zalloc(fs->blksz); 172 if (!journal_ptr[gindex]->buf) 173 return -ENOMEM; 174 175 memcpy(journal_ptr[gindex]->buf, journal_buffer, fs->blksz); 176 journal_ptr[gindex++]->blknr = blknr; 177 178 return 0; 179 } 180 181 /* 182 * This function stores the modified meta data in RAM 183 * metadata_buffer -- Buffer containing meta data 184 * blknr -- Block number on disk of the meta data buffer 185 */ 186 int ext4fs_put_metadata(char *metadata_buffer, uint32_t blknr) 187 { 188 struct ext_filesystem *fs = get_fs(); 189 if (!metadata_buffer) { 190 printf("Invalid input arguments %s\n", __func__); 191 return -EINVAL; 192 } 193 if (dirty_block_ptr[gd_index]->buf) 194 assert(dirty_block_ptr[gd_index]->blknr == blknr); 195 else 196 dirty_block_ptr[gd_index]->buf = zalloc(fs->blksz); 197 198 if (!dirty_block_ptr[gd_index]->buf) 199 return -ENOMEM; 200 memcpy(dirty_block_ptr[gd_index]->buf, metadata_buffer, fs->blksz); 201 dirty_block_ptr[gd_index++]->blknr = blknr; 202 203 return 0; 204 } 205 206 void print_revoke_blks(char *revk_blk) 207 { 208 int offset; 209 int max; 210 long int blocknr; 211 struct journal_revoke_header_t *header; 212 213 if (revk_blk == NULL) 214 return; 215 216 header = (struct journal_revoke_header_t *) revk_blk; 217 offset = sizeof(struct journal_revoke_header_t); 218 max = be32_to_cpu(header->r_count); 219 printf("total bytes %d\n", max); 220 221 while (offset < max) { 222 blocknr = be32_to_cpu(*((__be32 *)(revk_blk + offset))); 223 printf("revoke blknr is %ld\n", blocknr); 224 offset += 4; 225 } 226 } 227 228 static struct revoke_blk_list *_get_node(void) 229 { 230 struct revoke_blk_list *tmp_node; 231 tmp_node = zalloc(sizeof(struct revoke_blk_list)); 232 if (tmp_node == NULL) 233 return NULL; 234 tmp_node->content = NULL; 235 tmp_node->next = NULL; 236 237 return tmp_node; 238 } 239 240 void ext4fs_push_revoke_blk(char *buffer) 241 { 242 struct revoke_blk_list *node = NULL; 243 struct ext_filesystem *fs = get_fs(); 244 if (buffer == NULL) { 245 printf("buffer ptr is NULL\n"); 246 return; 247 } 248 node = _get_node(); 249 if (!node) { 250 printf("_get_node: malloc failed\n"); 251 return; 252 } 253 254 node->content = zalloc(fs->blksz); 255 if (node->content == NULL) 256 return; 257 memcpy(node->content, buffer, fs->blksz); 258 259 if (first_node == true) { 260 revk_blk_list = node; 261 prev_node = node; 262 first_node = false; 263 } else { 264 prev_node->next = node; 265 prev_node = node; 266 } 267 } 268 269 void ext4fs_free_revoke_blks(void) 270 { 271 struct revoke_blk_list *tmp_node = revk_blk_list; 272 struct revoke_blk_list *next_node = NULL; 273 274 while (tmp_node != NULL) { 275 if (tmp_node->content) 276 free(tmp_node->content); 277 tmp_node = tmp_node->next; 278 } 279 280 tmp_node = revk_blk_list; 281 while (tmp_node != NULL) { 282 next_node = tmp_node->next; 283 free(tmp_node); 284 tmp_node = next_node; 285 } 286 287 revk_blk_list = NULL; 288 prev_node = NULL; 289 first_node = true; 290 } 291 292 int check_blknr_for_revoke(long int blknr, int sequence_no) 293 { 294 struct journal_revoke_header_t *header; 295 int offset; 296 int max; 297 long int blocknr; 298 char *revk_blk; 299 struct revoke_blk_list *tmp_revk_node = revk_blk_list; 300 while (tmp_revk_node != NULL) { 301 revk_blk = tmp_revk_node->content; 302 303 header = (struct journal_revoke_header_t *) revk_blk; 304 if (sequence_no < be32_to_cpu(header->r_header.h_sequence)) { 305 offset = sizeof(struct journal_revoke_header_t); 306 max = be32_to_cpu(header->r_count); 307 308 while (offset < max) { 309 blocknr = be32_to_cpu(*((__be32 *) 310 (revk_blk + offset))); 311 if (blocknr == blknr) 312 goto found; 313 offset += 4; 314 } 315 } 316 tmp_revk_node = tmp_revk_node->next; 317 } 318 319 return -1; 320 321 found: 322 return 0; 323 } 324 325 /* 326 * This function parses the journal blocks and replays the 327 * suceessful transactions. A transaction is successfull 328 * if commit block is found for a descriptor block 329 * The tags in descriptor block contain the disk block 330 * numbers of the metadata to be replayed 331 */ 332 void recover_transaction(int prev_desc_logical_no) 333 { 334 struct ext2_inode inode_journal; 335 struct ext_filesystem *fs = get_fs(); 336 struct journal_header_t *jdb; 337 long int blknr; 338 char *p_jdb; 339 int ofs, flags; 340 int i; 341 struct ext3_journal_block_tag *tag; 342 char *temp_buff = zalloc(fs->blksz); 343 char *metadata_buff = zalloc(fs->blksz); 344 if (!temp_buff || !metadata_buff) 345 goto fail; 346 i = prev_desc_logical_no; 347 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, 348 (struct ext2_inode *)&inode_journal); 349 blknr = read_allocated_block((struct ext2_inode *) 350 &inode_journal, i); 351 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz, 352 temp_buff); 353 p_jdb = (char *)temp_buff; 354 jdb = (struct journal_header_t *) temp_buff; 355 ofs = sizeof(struct journal_header_t); 356 357 do { 358 tag = (struct ext3_journal_block_tag *)(p_jdb + ofs); 359 ofs += sizeof(struct ext3_journal_block_tag); 360 361 if (ofs > fs->blksz) 362 break; 363 364 flags = be32_to_cpu(tag->flags); 365 if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID)) 366 ofs += 16; 367 368 i++; 369 debug("\t\ttag %u\n", be32_to_cpu(tag->block)); 370 if (revk_blk_list != NULL) { 371 if (check_blknr_for_revoke(be32_to_cpu(tag->block), 372 be32_to_cpu(jdb->h_sequence)) == 0) 373 continue; 374 } 375 blknr = read_allocated_block(&inode_journal, i); 376 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, 377 fs->blksz, metadata_buff); 378 put_ext4((uint64_t)((uint64_t)be32_to_cpu(tag->block) * (uint64_t)fs->blksz), 379 metadata_buff, (uint32_t) fs->blksz); 380 } while (!(flags & EXT3_JOURNAL_FLAG_LAST_TAG)); 381 fail: 382 free(temp_buff); 383 free(metadata_buff); 384 } 385 386 void print_jrnl_status(int recovery_flag) 387 { 388 if (recovery_flag == RECOVER) 389 printf("Journal Recovery Completed\n"); 390 else 391 printf("Journal Scan Completed\n"); 392 } 393 394 int ext4fs_check_journal_state(int recovery_flag) 395 { 396 int i; 397 int DB_FOUND = NO; 398 long int blknr; 399 int transaction_state = TRANSACTION_COMPLETE; 400 int prev_desc_logical_no = 0; 401 int curr_desc_logical_no = 0; 402 int ofs, flags; 403 struct ext2_inode inode_journal; 404 struct journal_superblock_t *jsb = NULL; 405 struct journal_header_t *jdb = NULL; 406 char *p_jdb = NULL; 407 struct ext3_journal_block_tag *tag = NULL; 408 char *temp_buff = NULL; 409 char *temp_buff1 = NULL; 410 struct ext_filesystem *fs = get_fs(); 411 412 temp_buff = zalloc(fs->blksz); 413 if (!temp_buff) 414 return -ENOMEM; 415 temp_buff1 = zalloc(fs->blksz); 416 if (!temp_buff1) { 417 free(temp_buff); 418 return -ENOMEM; 419 } 420 421 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal); 422 blknr = read_allocated_block(&inode_journal, EXT2_JOURNAL_SUPERBLOCK); 423 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz, 424 temp_buff); 425 jsb = (struct journal_superblock_t *) temp_buff; 426 427 if (le32_to_cpu(fs->sb->feature_incompat) & EXT3_FEATURE_INCOMPAT_RECOVER) { 428 if (recovery_flag == RECOVER) 429 printf("Recovery required\n"); 430 } else { 431 if (recovery_flag == RECOVER) 432 printf("File System is consistent\n"); 433 goto end; 434 } 435 436 if (be32_to_cpu(jsb->s_start) == 0) 437 goto end; 438 439 if (!(jsb->s_feature_compat & 440 cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM))) 441 jsb->s_feature_compat |= 442 cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM); 443 444 i = be32_to_cpu(jsb->s_first); 445 while (1) { 446 blknr = read_allocated_block(&inode_journal, i); 447 memset(temp_buff1, '\0', fs->blksz); 448 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 449 0, fs->blksz, temp_buff1); 450 jdb = (struct journal_header_t *) temp_buff1; 451 452 if (be32_to_cpu(jdb->h_blocktype) == 453 EXT3_JOURNAL_DESCRIPTOR_BLOCK) { 454 if (be32_to_cpu(jdb->h_sequence) != 455 be32_to_cpu(jsb->s_sequence)) { 456 print_jrnl_status(recovery_flag); 457 break; 458 } 459 460 curr_desc_logical_no = i; 461 if (transaction_state == TRANSACTION_COMPLETE) 462 transaction_state = TRANSACTION_RUNNING; 463 else 464 return -1; 465 p_jdb = (char *)temp_buff1; 466 ofs = sizeof(struct journal_header_t); 467 do { 468 tag = (struct ext3_journal_block_tag *) 469 (p_jdb + ofs); 470 ofs += sizeof(struct ext3_journal_block_tag); 471 if (ofs > fs->blksz) 472 break; 473 flags = be32_to_cpu(tag->flags); 474 if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID)) 475 ofs += 16; 476 i++; 477 debug("\t\ttag %u\n", be32_to_cpu(tag->block)); 478 } while (!(flags & EXT3_JOURNAL_FLAG_LAST_TAG)); 479 i++; 480 DB_FOUND = YES; 481 } else if (be32_to_cpu(jdb->h_blocktype) == 482 EXT3_JOURNAL_COMMIT_BLOCK) { 483 if (be32_to_cpu(jdb->h_sequence) != 484 be32_to_cpu(jsb->s_sequence)) { 485 print_jrnl_status(recovery_flag); 486 break; 487 } 488 489 if (transaction_state == TRANSACTION_RUNNING || 490 (DB_FOUND == NO)) { 491 transaction_state = TRANSACTION_COMPLETE; 492 i++; 493 jsb->s_sequence = 494 cpu_to_be32(be32_to_cpu( 495 jsb->s_sequence) + 1); 496 } 497 prev_desc_logical_no = curr_desc_logical_no; 498 if ((recovery_flag == RECOVER) && (DB_FOUND == YES)) 499 recover_transaction(prev_desc_logical_no); 500 501 DB_FOUND = NO; 502 } else if (be32_to_cpu(jdb->h_blocktype) == 503 EXT3_JOURNAL_REVOKE_BLOCK) { 504 if (be32_to_cpu(jdb->h_sequence) != 505 be32_to_cpu(jsb->s_sequence)) { 506 print_jrnl_status(recovery_flag); 507 break; 508 } 509 if (recovery_flag == SCAN) 510 ext4fs_push_revoke_blk((char *)jdb); 511 i++; 512 } else { 513 debug("Else Case\n"); 514 if (be32_to_cpu(jdb->h_sequence) != 515 be32_to_cpu(jsb->s_sequence)) { 516 print_jrnl_status(recovery_flag); 517 break; 518 } 519 } 520 } 521 522 end: 523 if (recovery_flag == RECOVER) { 524 uint32_t new_feature_incompat; 525 jsb->s_start = cpu_to_be32(1); 526 jsb->s_sequence = cpu_to_be32(be32_to_cpu(jsb->s_sequence) + 1); 527 /* get the superblock */ 528 ext4_read_superblock((char *)fs->sb); 529 new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat); 530 new_feature_incompat |= EXT3_FEATURE_INCOMPAT_RECOVER; 531 fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat); 532 533 /* Update the super block */ 534 put_ext4((uint64_t) (SUPERBLOCK_SIZE), 535 (struct ext2_sblock *)fs->sb, 536 (uint32_t) SUPERBLOCK_SIZE); 537 ext4_read_superblock((char *)fs->sb); 538 539 blknr = read_allocated_block(&inode_journal, 540 EXT2_JOURNAL_SUPERBLOCK); 541 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), 542 (struct journal_superblock_t *)temp_buff, 543 (uint32_t) fs->blksz); 544 ext4fs_free_revoke_blks(); 545 } 546 free(temp_buff); 547 free(temp_buff1); 548 549 return 0; 550 } 551 552 static void update_descriptor_block(long int blknr) 553 { 554 int i; 555 long int jsb_blknr; 556 struct journal_header_t jdb; 557 struct ext3_journal_block_tag tag; 558 struct ext2_inode inode_journal; 559 struct journal_superblock_t *jsb = NULL; 560 char *buf = NULL; 561 char *temp = NULL; 562 struct ext_filesystem *fs = get_fs(); 563 char *temp_buff = zalloc(fs->blksz); 564 if (!temp_buff) 565 return; 566 567 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal); 568 jsb_blknr = read_allocated_block(&inode_journal, 569 EXT2_JOURNAL_SUPERBLOCK); 570 ext4fs_devread((lbaint_t)jsb_blknr * fs->sect_perblk, 0, fs->blksz, 571 temp_buff); 572 jsb = (struct journal_superblock_t *) temp_buff; 573 574 jdb.h_blocktype = cpu_to_be32(EXT3_JOURNAL_DESCRIPTOR_BLOCK); 575 jdb.h_magic = cpu_to_be32(EXT3_JOURNAL_MAGIC_NUMBER); 576 jdb.h_sequence = jsb->s_sequence; 577 buf = zalloc(fs->blksz); 578 if (!buf) { 579 free(temp_buff); 580 return; 581 } 582 temp = buf; 583 memcpy(buf, &jdb, sizeof(struct journal_header_t)); 584 temp += sizeof(struct journal_header_t); 585 586 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { 587 if (journal_ptr[i]->blknr == -1) 588 break; 589 590 tag.block = cpu_to_be32(journal_ptr[i]->blknr); 591 tag.flags = cpu_to_be32(EXT3_JOURNAL_FLAG_SAME_UUID); 592 memcpy(temp, &tag, sizeof(struct ext3_journal_block_tag)); 593 temp = temp + sizeof(struct ext3_journal_block_tag); 594 } 595 596 tag.block = cpu_to_be32(journal_ptr[--i]->blknr); 597 tag.flags = cpu_to_be32(EXT3_JOURNAL_FLAG_LAST_TAG); 598 memcpy(temp - sizeof(struct ext3_journal_block_tag), &tag, 599 sizeof(struct ext3_journal_block_tag)); 600 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), buf, (uint32_t) fs->blksz); 601 602 free(temp_buff); 603 free(buf); 604 } 605 606 static void update_commit_block(long int blknr) 607 { 608 struct journal_header_t jdb; 609 struct ext_filesystem *fs = get_fs(); 610 char *buf = NULL; 611 struct ext2_inode inode_journal; 612 struct journal_superblock_t *jsb; 613 long int jsb_blknr; 614 char *temp_buff = zalloc(fs->blksz); 615 if (!temp_buff) 616 return; 617 618 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, 619 &inode_journal); 620 jsb_blknr = read_allocated_block(&inode_journal, 621 EXT2_JOURNAL_SUPERBLOCK); 622 ext4fs_devread((lbaint_t)jsb_blknr * fs->sect_perblk, 0, fs->blksz, 623 temp_buff); 624 jsb = (struct journal_superblock_t *) temp_buff; 625 626 jdb.h_blocktype = cpu_to_be32(EXT3_JOURNAL_COMMIT_BLOCK); 627 jdb.h_magic = cpu_to_be32(EXT3_JOURNAL_MAGIC_NUMBER); 628 jdb.h_sequence = jsb->s_sequence; 629 buf = zalloc(fs->blksz); 630 if (!buf) { 631 free(temp_buff); 632 return; 633 } 634 memcpy(buf, &jdb, sizeof(struct journal_header_t)); 635 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), buf, (uint32_t) fs->blksz); 636 637 free(temp_buff); 638 free(buf); 639 } 640 641 void ext4fs_update_journal(void) 642 { 643 struct ext2_inode inode_journal; 644 struct ext_filesystem *fs = get_fs(); 645 long int blknr; 646 int i; 647 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal); 648 blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++); 649 update_descriptor_block(blknr); 650 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { 651 if (journal_ptr[i]->blknr == -1) 652 break; 653 blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++); 654 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), 655 journal_ptr[i]->buf, fs->blksz); 656 } 657 blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++); 658 update_commit_block(blknr); 659 printf("update journal finished\n"); 660 } 661