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 * ext4ls and ext4load : Based on ext2 ls and load support in Uboot. 9 * Ext4 read optimization taken from Open-Moko 10 * Qi bootloader 11 * 12 * (C) Copyright 2004 13 * esd gmbh <www.esd-electronics.com> 14 * Reinhard Arlt <reinhard.arlt@esd-electronics.com> 15 * 16 * based on code from grub2 fs/ext2.c and fs/fshelp.c by 17 * GRUB -- GRand Unified Bootloader 18 * Copyright (C) 2003, 2004 Free Software Foundation, Inc. 19 * 20 * ext4write : Based on generic ext4 protocol. 21 */ 22 23 24 #include <common.h> 25 #include <memalign.h> 26 #include <linux/stat.h> 27 #include <div64.h> 28 #include "ext4_common.h" 29 30 static inline void ext4fs_sb_free_inodes_inc(struct ext2_sblock *sb) 31 { 32 sb->free_inodes = cpu_to_le32(le32_to_cpu(sb->free_inodes) + 1); 33 } 34 35 static inline void ext4fs_sb_free_blocks_inc(struct ext2_sblock *sb) 36 { 37 sb->free_blocks = cpu_to_le32(le32_to_cpu(sb->free_blocks) + 1); 38 } 39 40 static inline void ext4fs_bg_free_inodes_inc 41 (struct ext2_block_group *bg, const struct ext_filesystem *fs) 42 { 43 uint32_t free_inodes = le16_to_cpu(bg->free_inodes); 44 if (fs->gdsize == 64) 45 free_inodes += le16_to_cpu(bg->free_inodes_high) << 16; 46 free_inodes++; 47 48 bg->free_inodes = cpu_to_le16(free_inodes & 0xffff); 49 if (fs->gdsize == 64) 50 bg->free_inodes_high = cpu_to_le16(free_inodes >> 16); 51 } 52 53 static inline void ext4fs_bg_free_blocks_inc 54 (struct ext2_block_group *bg, const struct ext_filesystem *fs) 55 { 56 uint32_t free_blocks = le16_to_cpu(bg->free_blocks); 57 if (fs->gdsize == 64) 58 free_blocks += le16_to_cpu(bg->free_blocks_high) << 16; 59 free_blocks++; 60 61 bg->free_blocks = cpu_to_le16(free_blocks & 0xffff); 62 if (fs->gdsize == 64) 63 bg->free_blocks_high = cpu_to_le16(free_blocks >> 16); 64 } 65 66 static void ext4fs_update(void) 67 { 68 short i; 69 ext4fs_update_journal(); 70 struct ext_filesystem *fs = get_fs(); 71 struct ext2_block_group *bgd = NULL; 72 73 /* update super block */ 74 put_ext4((uint64_t)(SUPERBLOCK_SIZE), 75 (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE); 76 77 /* update block bitmaps */ 78 for (i = 0; i < fs->no_blkgrp; i++) { 79 bgd = ext4fs_get_group_descriptor(fs, i); 80 bgd->bg_checksum = cpu_to_le16(ext4fs_checksum_update(i)); 81 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); 82 put_ext4(b_bitmap_blk * fs->blksz, 83 fs->blk_bmaps[i], fs->blksz); 84 } 85 86 /* update inode bitmaps */ 87 for (i = 0; i < fs->no_blkgrp; i++) { 88 bgd = ext4fs_get_group_descriptor(fs, i); 89 uint64_t i_bitmap_blk = ext4fs_bg_get_inode_id(bgd, fs); 90 put_ext4(i_bitmap_blk * fs->blksz, 91 fs->inode_bmaps[i], fs->blksz); 92 } 93 94 /* update the block group descriptor table */ 95 put_ext4((uint64_t)((uint64_t)fs->gdtable_blkno * (uint64_t)fs->blksz), 96 (struct ext2_block_group *)fs->gdtable, 97 (fs->blksz * fs->no_blk_pergdt)); 98 99 ext4fs_dump_metadata(); 100 101 gindex = 0; 102 gd_index = 0; 103 } 104 105 int ext4fs_get_bgdtable(void) 106 { 107 int status; 108 struct ext_filesystem *fs = get_fs(); 109 int gdsize_total = ROUND(fs->no_blkgrp * fs->gdsize, fs->blksz); 110 fs->no_blk_pergdt = gdsize_total / fs->blksz; 111 112 /* allocate memory for gdtable */ 113 fs->gdtable = zalloc(gdsize_total); 114 if (!fs->gdtable) 115 return -ENOMEM; 116 /* read the group descriptor table */ 117 status = ext4fs_devread((lbaint_t)fs->gdtable_blkno * fs->sect_perblk, 118 0, fs->blksz * fs->no_blk_pergdt, fs->gdtable); 119 if (status == 0) 120 goto fail; 121 122 if (ext4fs_log_gdt(fs->gdtable)) { 123 printf("Error in ext4fs_log_gdt\n"); 124 return -1; 125 } 126 127 return 0; 128 fail: 129 free(fs->gdtable); 130 fs->gdtable = NULL; 131 132 return -1; 133 } 134 135 static void delete_single_indirect_block(struct ext2_inode *inode) 136 { 137 struct ext2_block_group *bgd = NULL; 138 static int prev_bg_bmap_idx = -1; 139 uint32_t blknr; 140 int remainder; 141 int bg_idx; 142 int status; 143 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); 144 struct ext_filesystem *fs = get_fs(); 145 char *journal_buffer = zalloc(fs->blksz); 146 if (!journal_buffer) { 147 printf("No memory\n"); 148 return; 149 } 150 151 /* deleting the single indirect block associated with inode */ 152 if (inode->b.blocks.indir_block != 0) { 153 blknr = le32_to_cpu(inode->b.blocks.indir_block); 154 debug("SIPB releasing %u\n", blknr); 155 bg_idx = blknr / blk_per_grp; 156 if (fs->blksz == 1024) { 157 remainder = blknr % blk_per_grp; 158 if (!remainder) 159 bg_idx--; 160 } 161 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); 162 /* get block group descriptor table */ 163 bgd = ext4fs_get_group_descriptor(fs, bg_idx); 164 ext4fs_bg_free_blocks_inc(bgd, fs); 165 ext4fs_sb_free_blocks_inc(fs->sb); 166 /* journal backup */ 167 if (prev_bg_bmap_idx != bg_idx) { 168 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); 169 status = ext4fs_devread( 170 b_bitmap_blk * fs->sect_perblk, 171 0, fs->blksz, journal_buffer); 172 if (status == 0) 173 goto fail; 174 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) 175 goto fail; 176 prev_bg_bmap_idx = bg_idx; 177 } 178 } 179 fail: 180 free(journal_buffer); 181 } 182 183 static void delete_double_indirect_block(struct ext2_inode *inode) 184 { 185 int i; 186 short status; 187 static int prev_bg_bmap_idx = -1; 188 uint32_t blknr; 189 int remainder; 190 int bg_idx; 191 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); 192 __le32 *di_buffer = NULL; 193 void *dib_start_addr = NULL; 194 struct ext2_block_group *bgd = NULL; 195 struct ext_filesystem *fs = get_fs(); 196 char *journal_buffer = zalloc(fs->blksz); 197 if (!journal_buffer) { 198 printf("No memory\n"); 199 return; 200 } 201 202 if (inode->b.blocks.double_indir_block != 0) { 203 di_buffer = zalloc(fs->blksz); 204 if (!di_buffer) { 205 printf("No memory\n"); 206 return; 207 } 208 dib_start_addr = di_buffer; 209 blknr = le32_to_cpu(inode->b.blocks.double_indir_block); 210 status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, 211 fs->blksz, (char *)di_buffer); 212 for (i = 0; i < fs->blksz / sizeof(int); i++) { 213 if (*di_buffer == 0) 214 break; 215 216 debug("DICB releasing %u\n", *di_buffer); 217 bg_idx = le32_to_cpu(*di_buffer) / blk_per_grp; 218 if (fs->blksz == 1024) { 219 remainder = le32_to_cpu(*di_buffer) % blk_per_grp; 220 if (!remainder) 221 bg_idx--; 222 } 223 /* get block group descriptor table */ 224 bgd = ext4fs_get_group_descriptor(fs, bg_idx); 225 ext4fs_reset_block_bmap(le32_to_cpu(*di_buffer), 226 fs->blk_bmaps[bg_idx], bg_idx); 227 di_buffer++; 228 ext4fs_bg_free_blocks_inc(bgd, fs); 229 ext4fs_sb_free_blocks_inc(fs->sb); 230 /* journal backup */ 231 if (prev_bg_bmap_idx != bg_idx) { 232 uint64_t b_bitmap_blk = 233 ext4fs_bg_get_block_id(bgd, fs); 234 status = ext4fs_devread(b_bitmap_blk 235 * fs->sect_perblk, 0, 236 fs->blksz, 237 journal_buffer); 238 if (status == 0) 239 goto fail; 240 241 if (ext4fs_log_journal(journal_buffer, 242 b_bitmap_blk)) 243 goto fail; 244 prev_bg_bmap_idx = bg_idx; 245 } 246 } 247 248 /* removing the parent double indirect block */ 249 blknr = le32_to_cpu(inode->b.blocks.double_indir_block); 250 bg_idx = blknr / blk_per_grp; 251 if (fs->blksz == 1024) { 252 remainder = blknr % blk_per_grp; 253 if (!remainder) 254 bg_idx--; 255 } 256 /* get block group descriptor table */ 257 bgd = ext4fs_get_group_descriptor(fs, bg_idx); 258 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); 259 ext4fs_bg_free_blocks_inc(bgd, fs); 260 ext4fs_sb_free_blocks_inc(fs->sb); 261 /* journal backup */ 262 if (prev_bg_bmap_idx != bg_idx) { 263 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); 264 status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk, 265 0, fs->blksz, journal_buffer); 266 if (status == 0) 267 goto fail; 268 269 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) 270 goto fail; 271 prev_bg_bmap_idx = bg_idx; 272 } 273 debug("DIPB releasing %d\n", blknr); 274 } 275 fail: 276 free(dib_start_addr); 277 free(journal_buffer); 278 } 279 280 static void delete_triple_indirect_block(struct ext2_inode *inode) 281 { 282 int i, j; 283 short status; 284 static int prev_bg_bmap_idx = -1; 285 uint32_t blknr; 286 int remainder; 287 int bg_idx; 288 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); 289 __le32 *tigp_buffer = NULL; 290 void *tib_start_addr = NULL; 291 __le32 *tip_buffer = NULL; 292 void *tipb_start_addr = NULL; 293 struct ext2_block_group *bgd = NULL; 294 struct ext_filesystem *fs = get_fs(); 295 char *journal_buffer = zalloc(fs->blksz); 296 if (!journal_buffer) { 297 printf("No memory\n"); 298 return; 299 } 300 301 if (inode->b.blocks.triple_indir_block != 0) { 302 tigp_buffer = zalloc(fs->blksz); 303 if (!tigp_buffer) { 304 printf("No memory\n"); 305 return; 306 } 307 tib_start_addr = tigp_buffer; 308 blknr = le32_to_cpu(inode->b.blocks.triple_indir_block); 309 status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, 310 fs->blksz, (char *)tigp_buffer); 311 for (i = 0; i < fs->blksz / sizeof(int); i++) { 312 if (*tigp_buffer == 0) 313 break; 314 debug("tigp buffer releasing %u\n", *tigp_buffer); 315 316 tip_buffer = zalloc(fs->blksz); 317 if (!tip_buffer) 318 goto fail; 319 tipb_start_addr = tip_buffer; 320 status = ext4fs_devread((lbaint_t)le32_to_cpu(*tigp_buffer) * 321 fs->sect_perblk, 0, fs->blksz, 322 (char *)tip_buffer); 323 for (j = 0; j < fs->blksz / sizeof(int); j++) { 324 if (le32_to_cpu(*tip_buffer) == 0) 325 break; 326 bg_idx = le32_to_cpu(*tip_buffer) / blk_per_grp; 327 if (fs->blksz == 1024) { 328 remainder = le32_to_cpu(*tip_buffer) % blk_per_grp; 329 if (!remainder) 330 bg_idx--; 331 } 332 333 ext4fs_reset_block_bmap(le32_to_cpu(*tip_buffer), 334 fs->blk_bmaps[bg_idx], 335 bg_idx); 336 337 tip_buffer++; 338 /* get block group descriptor table */ 339 bgd = ext4fs_get_group_descriptor(fs, bg_idx); 340 ext4fs_bg_free_blocks_inc(bgd, fs); 341 ext4fs_sb_free_blocks_inc(fs->sb); 342 /* journal backup */ 343 if (prev_bg_bmap_idx != bg_idx) { 344 uint64_t b_bitmap_blk = 345 ext4fs_bg_get_block_id(bgd, fs); 346 status = 347 ext4fs_devread( 348 b_bitmap_blk * 349 fs->sect_perblk, 0, 350 fs->blksz, 351 journal_buffer); 352 if (status == 0) 353 goto fail; 354 355 if (ext4fs_log_journal(journal_buffer, 356 b_bitmap_blk)) 357 goto fail; 358 prev_bg_bmap_idx = bg_idx; 359 } 360 } 361 free(tipb_start_addr); 362 tipb_start_addr = NULL; 363 364 /* 365 * removing the grand parent blocks 366 * which is connected to inode 367 */ 368 bg_idx = le32_to_cpu(*tigp_buffer) / blk_per_grp; 369 if (fs->blksz == 1024) { 370 remainder = le32_to_cpu(*tigp_buffer) % blk_per_grp; 371 if (!remainder) 372 bg_idx--; 373 } 374 ext4fs_reset_block_bmap(le32_to_cpu(*tigp_buffer), 375 fs->blk_bmaps[bg_idx], bg_idx); 376 377 tigp_buffer++; 378 /* get block group descriptor table */ 379 bgd = ext4fs_get_group_descriptor(fs, bg_idx); 380 ext4fs_bg_free_blocks_inc(bgd, fs); 381 ext4fs_sb_free_blocks_inc(fs->sb); 382 /* journal backup */ 383 if (prev_bg_bmap_idx != bg_idx) { 384 uint64_t b_bitmap_blk = 385 ext4fs_bg_get_block_id(bgd, fs); 386 memset(journal_buffer, '\0', fs->blksz); 387 status = ext4fs_devread(b_bitmap_blk * 388 fs->sect_perblk, 0, 389 fs->blksz, 390 journal_buffer); 391 if (status == 0) 392 goto fail; 393 394 if (ext4fs_log_journal(journal_buffer, 395 b_bitmap_blk)) 396 goto fail; 397 prev_bg_bmap_idx = bg_idx; 398 } 399 } 400 401 /* removing the grand parent triple indirect block */ 402 blknr = le32_to_cpu(inode->b.blocks.triple_indir_block); 403 bg_idx = blknr / blk_per_grp; 404 if (fs->blksz == 1024) { 405 remainder = blknr % blk_per_grp; 406 if (!remainder) 407 bg_idx--; 408 } 409 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); 410 /* get block group descriptor table */ 411 bgd = ext4fs_get_group_descriptor(fs, bg_idx); 412 ext4fs_bg_free_blocks_inc(bgd, fs); 413 ext4fs_sb_free_blocks_inc(fs->sb); 414 /* journal backup */ 415 if (prev_bg_bmap_idx != bg_idx) { 416 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); 417 status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk, 418 0, fs->blksz, journal_buffer); 419 if (status == 0) 420 goto fail; 421 422 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) 423 goto fail; 424 prev_bg_bmap_idx = bg_idx; 425 } 426 debug("tigp buffer itself releasing %d\n", blknr); 427 } 428 fail: 429 free(tib_start_addr); 430 free(tipb_start_addr); 431 free(journal_buffer); 432 } 433 434 static int ext4fs_delete_file(int inodeno) 435 { 436 struct ext2_inode inode; 437 short status; 438 int i; 439 int remainder; 440 long int blknr; 441 int bg_idx; 442 int ibmap_idx; 443 char *read_buffer = NULL; 444 char *start_block_address = NULL; 445 uint32_t no_blocks; 446 447 static int prev_bg_bmap_idx = -1; 448 unsigned int inodes_per_block; 449 uint32_t blkno; 450 unsigned int blkoff; 451 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); 452 uint32_t inode_per_grp = le32_to_cpu(ext4fs_root->sblock.inodes_per_group); 453 struct ext2_inode *inode_buffer = NULL; 454 struct ext2_block_group *bgd = NULL; 455 struct ext_filesystem *fs = get_fs(); 456 char *journal_buffer = zalloc(fs->blksz); 457 if (!journal_buffer) 458 return -ENOMEM; 459 status = ext4fs_read_inode(ext4fs_root, inodeno, &inode); 460 if (status == 0) 461 goto fail; 462 463 /* read the block no allocated to a file */ 464 no_blocks = le32_to_cpu(inode.size) / fs->blksz; 465 if (le32_to_cpu(inode.size) % fs->blksz) 466 no_blocks++; 467 468 if (le32_to_cpu(inode.flags) & EXT4_EXTENTS_FL) { 469 /* FIXME delete extent index blocks, i.e. eh_depth >= 1 */ 470 struct ext4_extent_header *eh = 471 (struct ext4_extent_header *) 472 inode.b.blocks.dir_blocks; 473 debug("del: dep=%d entries=%d\n", eh->eh_depth, eh->eh_entries); 474 } else { 475 delete_single_indirect_block(&inode); 476 delete_double_indirect_block(&inode); 477 delete_triple_indirect_block(&inode); 478 } 479 480 /* release data blocks */ 481 for (i = 0; i < no_blocks; i++) { 482 blknr = read_allocated_block(&inode, i); 483 if (blknr == 0) 484 continue; 485 if (blknr < 0) 486 goto fail; 487 bg_idx = blknr / blk_per_grp; 488 if (fs->blksz == 1024) { 489 remainder = blknr % blk_per_grp; 490 if (!remainder) 491 bg_idx--; 492 } 493 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], 494 bg_idx); 495 debug("EXT4 Block releasing %ld: %d\n", blknr, bg_idx); 496 497 /* get block group descriptor table */ 498 bgd = ext4fs_get_group_descriptor(fs, bg_idx); 499 ext4fs_bg_free_blocks_inc(bgd, fs); 500 ext4fs_sb_free_blocks_inc(fs->sb); 501 /* journal backup */ 502 if (prev_bg_bmap_idx != bg_idx) { 503 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); 504 status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk, 505 0, fs->blksz, 506 journal_buffer); 507 if (status == 0) 508 goto fail; 509 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) 510 goto fail; 511 prev_bg_bmap_idx = bg_idx; 512 } 513 } 514 515 /* release inode */ 516 /* from the inode no to blockno */ 517 inodes_per_block = fs->blksz / fs->inodesz; 518 ibmap_idx = inodeno / inode_per_grp; 519 520 /* get the block no */ 521 inodeno--; 522 /* get block group descriptor table */ 523 bgd = ext4fs_get_group_descriptor(fs, ibmap_idx); 524 blkno = ext4fs_bg_get_inode_table_id(bgd, fs) + 525 (inodeno % inode_per_grp) / inodes_per_block; 526 527 /* get the offset of the inode */ 528 blkoff = ((inodeno) % inodes_per_block) * fs->inodesz; 529 530 /* read the block no containing the inode */ 531 read_buffer = zalloc(fs->blksz); 532 if (!read_buffer) 533 goto fail; 534 start_block_address = read_buffer; 535 status = ext4fs_devread((lbaint_t)blkno * fs->sect_perblk, 536 0, fs->blksz, read_buffer); 537 if (status == 0) 538 goto fail; 539 540 if (ext4fs_log_journal(read_buffer, blkno)) 541 goto fail; 542 543 read_buffer = read_buffer + blkoff; 544 inode_buffer = (struct ext2_inode *)read_buffer; 545 memset(inode_buffer, '\0', fs->inodesz); 546 547 /* write the inode to original position in inode table */ 548 if (ext4fs_put_metadata(start_block_address, blkno)) 549 goto fail; 550 551 /* update the respective inode bitmaps */ 552 inodeno++; 553 ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx); 554 ext4fs_bg_free_inodes_inc(bgd, fs); 555 ext4fs_sb_free_inodes_inc(fs->sb); 556 /* journal backup */ 557 memset(journal_buffer, '\0', fs->blksz); 558 status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) * 559 fs->sect_perblk, 0, fs->blksz, journal_buffer); 560 if (status == 0) 561 goto fail; 562 if (ext4fs_log_journal(journal_buffer, ext4fs_bg_get_inode_id(bgd, fs))) 563 goto fail; 564 565 ext4fs_update(); 566 ext4fs_deinit(); 567 ext4fs_reinit_global(); 568 569 if (ext4fs_init() != 0) { 570 printf("error in File System init\n"); 571 goto fail; 572 } 573 574 free(start_block_address); 575 free(journal_buffer); 576 577 return 0; 578 fail: 579 free(start_block_address); 580 free(journal_buffer); 581 582 return -1; 583 } 584 585 int ext4fs_init(void) 586 { 587 short status; 588 int i; 589 uint32_t real_free_blocks = 0; 590 struct ext_filesystem *fs = get_fs(); 591 592 /* populate fs */ 593 fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root); 594 fs->sect_perblk = fs->blksz >> fs->dev_desc->log2blksz; 595 596 /* get the superblock */ 597 fs->sb = zalloc(SUPERBLOCK_SIZE); 598 if (!fs->sb) 599 return -ENOMEM; 600 if (!ext4_read_superblock((char *)fs->sb)) 601 goto fail; 602 603 /* init journal */ 604 if (ext4fs_init_journal()) 605 goto fail; 606 607 /* get total no of blockgroups */ 608 fs->no_blkgrp = (uint32_t)ext4fs_div_roundup( 609 le32_to_cpu(ext4fs_root->sblock.total_blocks) 610 - le32_to_cpu(ext4fs_root->sblock.first_data_block), 611 le32_to_cpu(ext4fs_root->sblock.blocks_per_group)); 612 613 /* get the block group descriptor table */ 614 fs->gdtable_blkno = ((EXT2_MIN_BLOCK_SIZE == fs->blksz) + 1); 615 if (ext4fs_get_bgdtable() == -1) { 616 printf("Error in getting the block group descriptor table\n"); 617 goto fail; 618 } 619 620 /* load all the available bitmap block of the partition */ 621 fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *)); 622 if (!fs->blk_bmaps) 623 goto fail; 624 for (i = 0; i < fs->no_blkgrp; i++) { 625 fs->blk_bmaps[i] = zalloc(fs->blksz); 626 if (!fs->blk_bmaps[i]) 627 goto fail; 628 } 629 630 for (i = 0; i < fs->no_blkgrp; i++) { 631 struct ext2_block_group *bgd = 632 ext4fs_get_group_descriptor(fs, i); 633 status = ext4fs_devread(ext4fs_bg_get_block_id(bgd, fs) * 634 fs->sect_perblk, 0, 635 fs->blksz, (char *)fs->blk_bmaps[i]); 636 if (status == 0) 637 goto fail; 638 } 639 640 /* load all the available inode bitmap of the partition */ 641 fs->inode_bmaps = zalloc(fs->no_blkgrp * sizeof(unsigned char *)); 642 if (!fs->inode_bmaps) 643 goto fail; 644 for (i = 0; i < fs->no_blkgrp; i++) { 645 fs->inode_bmaps[i] = zalloc(fs->blksz); 646 if (!fs->inode_bmaps[i]) 647 goto fail; 648 } 649 650 for (i = 0; i < fs->no_blkgrp; i++) { 651 struct ext2_block_group *bgd = 652 ext4fs_get_group_descriptor(fs, i); 653 status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) * 654 fs->sect_perblk, 655 0, fs->blksz, 656 (char *)fs->inode_bmaps[i]); 657 if (status == 0) 658 goto fail; 659 } 660 661 /* 662 * check filesystem consistency with free blocks of file system 663 * some time we observed that superblock freeblocks does not match 664 * with the blockgroups freeblocks when improper 665 * reboot of a linux kernel 666 */ 667 for (i = 0; i < fs->no_blkgrp; i++) { 668 struct ext2_block_group *bgd = 669 ext4fs_get_group_descriptor(fs, i); 670 real_free_blocks = real_free_blocks + 671 ext4fs_bg_get_free_blocks(bgd, fs); 672 } 673 if (real_free_blocks != ext4fs_sb_get_free_blocks(fs->sb)) 674 ext4fs_sb_set_free_blocks(fs->sb, real_free_blocks); 675 676 return 0; 677 fail: 678 ext4fs_deinit(); 679 680 return -1; 681 } 682 683 void ext4fs_deinit(void) 684 { 685 int i; 686 struct ext2_inode inode_journal; 687 struct journal_superblock_t *jsb; 688 uint32_t blknr; 689 struct ext_filesystem *fs = get_fs(); 690 uint32_t new_feature_incompat; 691 692 /* free journal */ 693 char *temp_buff = zalloc(fs->blksz); 694 if (temp_buff) { 695 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, 696 &inode_journal); 697 blknr = read_allocated_block(&inode_journal, 698 EXT2_JOURNAL_SUPERBLOCK); 699 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz, 700 temp_buff); 701 jsb = (struct journal_superblock_t *)temp_buff; 702 jsb->s_start = 0; 703 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), 704 (struct journal_superblock_t *)temp_buff, fs->blksz); 705 free(temp_buff); 706 } 707 ext4fs_free_journal(); 708 709 /* get the superblock */ 710 ext4_read_superblock((char *)fs->sb); 711 new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat); 712 new_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER; 713 fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat); 714 put_ext4((uint64_t)(SUPERBLOCK_SIZE), 715 (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE); 716 free(fs->sb); 717 fs->sb = NULL; 718 719 if (fs->blk_bmaps) { 720 for (i = 0; i < fs->no_blkgrp; i++) { 721 free(fs->blk_bmaps[i]); 722 fs->blk_bmaps[i] = NULL; 723 } 724 free(fs->blk_bmaps); 725 fs->blk_bmaps = NULL; 726 } 727 728 if (fs->inode_bmaps) { 729 for (i = 0; i < fs->no_blkgrp; i++) { 730 free(fs->inode_bmaps[i]); 731 fs->inode_bmaps[i] = NULL; 732 } 733 free(fs->inode_bmaps); 734 fs->inode_bmaps = NULL; 735 } 736 737 738 free(fs->gdtable); 739 fs->gdtable = NULL; 740 /* 741 * reinitiliazed the global inode and 742 * block bitmap first execution check variables 743 */ 744 fs->first_pass_ibmap = 0; 745 fs->first_pass_bbmap = 0; 746 fs->curr_inode_no = 0; 747 fs->curr_blkno = 0; 748 } 749 750 /* 751 * Write data to filesystem blocks. Uses same optimization for 752 * contigous sectors as ext4fs_read_file 753 */ 754 static int ext4fs_write_file(struct ext2_inode *file_inode, 755 int pos, unsigned int len, char *buf) 756 { 757 int i; 758 int blockcnt; 759 uint32_t filesize = le32_to_cpu(file_inode->size); 760 struct ext_filesystem *fs = get_fs(); 761 int log2blksz = fs->dev_desc->log2blksz; 762 int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz; 763 int previous_block_number = -1; 764 int delayed_start = 0; 765 int delayed_extent = 0; 766 int delayed_next = 0; 767 char *delayed_buf = NULL; 768 769 /* Adjust len so it we can't read past the end of the file. */ 770 if (len > filesize) 771 len = filesize; 772 773 blockcnt = ((len + pos) + fs->blksz - 1) / fs->blksz; 774 775 for (i = pos / fs->blksz; i < blockcnt; i++) { 776 long int blknr; 777 int blockend = fs->blksz; 778 int skipfirst = 0; 779 blknr = read_allocated_block(file_inode, i); 780 if (blknr <= 0) 781 return -1; 782 783 blknr = blknr << log2_fs_blocksize; 784 785 if (blknr) { 786 if (previous_block_number != -1) { 787 if (delayed_next == blknr) { 788 delayed_extent += blockend; 789 delayed_next += blockend >> log2blksz; 790 } else { /* spill */ 791 put_ext4((uint64_t) 792 ((uint64_t)delayed_start << log2blksz), 793 delayed_buf, 794 (uint32_t) delayed_extent); 795 previous_block_number = blknr; 796 delayed_start = blknr; 797 delayed_extent = blockend; 798 delayed_buf = buf; 799 delayed_next = blknr + 800 (blockend >> log2blksz); 801 } 802 } else { 803 previous_block_number = blknr; 804 delayed_start = blknr; 805 delayed_extent = blockend; 806 delayed_buf = buf; 807 delayed_next = blknr + 808 (blockend >> log2blksz); 809 } 810 } else { 811 if (previous_block_number != -1) { 812 /* spill */ 813 put_ext4((uint64_t) ((uint64_t)delayed_start << 814 log2blksz), 815 delayed_buf, 816 (uint32_t) delayed_extent); 817 previous_block_number = -1; 818 } 819 memset(buf, 0, fs->blksz - skipfirst); 820 } 821 buf += fs->blksz - skipfirst; 822 } 823 if (previous_block_number != -1) { 824 /* spill */ 825 put_ext4((uint64_t) ((uint64_t)delayed_start << log2blksz), 826 delayed_buf, (uint32_t) delayed_extent); 827 previous_block_number = -1; 828 } 829 830 return len; 831 } 832 833 int ext4fs_write(const char *fname, unsigned char *buffer, 834 unsigned long sizebytes) 835 { 836 int ret = 0; 837 struct ext2_inode *file_inode = NULL; 838 unsigned char *inode_buffer = NULL; 839 int parent_inodeno; 840 int inodeno; 841 time_t timestamp = 0; 842 843 uint64_t bytes_reqd_for_file; 844 unsigned int blks_reqd_for_file; 845 unsigned int blocks_remaining; 846 int existing_file_inodeno; 847 char *temp_ptr = NULL; 848 long int itable_blkno; 849 long int parent_itable_blkno; 850 long int blkoff; 851 struct ext2_sblock *sblock = &(ext4fs_root->sblock); 852 unsigned int inodes_per_block; 853 unsigned int ibmap_idx; 854 struct ext2_block_group *bgd = NULL; 855 struct ext_filesystem *fs = get_fs(); 856 ALLOC_CACHE_ALIGN_BUFFER(char, filename, 256); 857 memset(filename, 0x00, 256); 858 859 g_parent_inode = zalloc(fs->inodesz); 860 if (!g_parent_inode) 861 goto fail; 862 863 if (ext4fs_init() != 0) { 864 printf("error in File System init\n"); 865 return -1; 866 } 867 868 if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) { 869 printf("Unsupported feature metadata_csum found, not writing.\n"); 870 return -1; 871 } 872 873 inodes_per_block = fs->blksz / fs->inodesz; 874 parent_inodeno = ext4fs_get_parent_inode_num(fname, filename, F_FILE); 875 if (parent_inodeno == -1) 876 goto fail; 877 if (ext4fs_iget(parent_inodeno, g_parent_inode)) 878 goto fail; 879 /* do not mess up a directory using hash trees */ 880 if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) { 881 printf("hash tree directory\n"); 882 goto fail; 883 } 884 /* check if the filename is already present in root */ 885 existing_file_inodeno = ext4fs_filename_unlink(filename); 886 if (existing_file_inodeno != -1) { 887 ret = ext4fs_delete_file(existing_file_inodeno); 888 fs->first_pass_bbmap = 0; 889 fs->curr_blkno = 0; 890 891 fs->first_pass_ibmap = 0; 892 fs->curr_inode_no = 0; 893 if (ret) 894 goto fail; 895 } 896 /* calucalate how many blocks required */ 897 bytes_reqd_for_file = sizebytes; 898 blks_reqd_for_file = lldiv(bytes_reqd_for_file, fs->blksz); 899 if (do_div(bytes_reqd_for_file, fs->blksz) != 0) { 900 blks_reqd_for_file++; 901 debug("total bytes for a file %u\n", blks_reqd_for_file); 902 } 903 blocks_remaining = blks_reqd_for_file; 904 /* test for available space in partition */ 905 if (le32_to_cpu(fs->sb->free_blocks) < blks_reqd_for_file) { 906 printf("Not enough space on partition !!!\n"); 907 goto fail; 908 } 909 910 inodeno = ext4fs_update_parent_dentry(filename, FILETYPE_REG); 911 if (inodeno == -1) 912 goto fail; 913 /* prepare file inode */ 914 inode_buffer = zalloc(fs->inodesz); 915 if (!inode_buffer) 916 goto fail; 917 file_inode = (struct ext2_inode *)inode_buffer; 918 file_inode->mode = cpu_to_le16(S_IFREG | S_IRWXU | 919 S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH); 920 /* ToDo: Update correct time */ 921 file_inode->mtime = cpu_to_le32(timestamp); 922 file_inode->atime = cpu_to_le32(timestamp); 923 file_inode->ctime = cpu_to_le32(timestamp); 924 file_inode->nlinks = cpu_to_le16(1); 925 file_inode->size = cpu_to_le32(sizebytes); 926 927 /* Allocate data blocks */ 928 ext4fs_allocate_blocks(file_inode, blocks_remaining, 929 &blks_reqd_for_file); 930 file_inode->blockcnt = cpu_to_le32((blks_reqd_for_file * fs->blksz) >> 931 fs->dev_desc->log2blksz); 932 933 temp_ptr = zalloc(fs->blksz); 934 if (!temp_ptr) 935 goto fail; 936 ibmap_idx = inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group); 937 inodeno--; 938 bgd = ext4fs_get_group_descriptor(fs, ibmap_idx); 939 itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) + 940 (inodeno % le32_to_cpu(sblock->inodes_per_group)) / 941 inodes_per_block; 942 blkoff = (inodeno % inodes_per_block) * fs->inodesz; 943 ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz, 944 temp_ptr); 945 if (ext4fs_log_journal(temp_ptr, itable_blkno)) 946 goto fail; 947 948 memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz); 949 if (ext4fs_put_metadata(temp_ptr, itable_blkno)) 950 goto fail; 951 /* copy the file content into data blocks */ 952 if (ext4fs_write_file(file_inode, 0, sizebytes, (char *)buffer) == -1) { 953 printf("Error in copying content\n"); 954 /* FIXME: Deallocate data blocks */ 955 goto fail; 956 } 957 ibmap_idx = parent_inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group); 958 parent_inodeno--; 959 bgd = ext4fs_get_group_descriptor(fs, ibmap_idx); 960 parent_itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) + 961 (parent_inodeno % 962 le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block; 963 blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz; 964 if (parent_itable_blkno != itable_blkno) { 965 memset(temp_ptr, '\0', fs->blksz); 966 ext4fs_devread((lbaint_t)parent_itable_blkno * fs->sect_perblk, 967 0, fs->blksz, temp_ptr); 968 if (ext4fs_log_journal(temp_ptr, parent_itable_blkno)) 969 goto fail; 970 971 memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz); 972 if (ext4fs_put_metadata(temp_ptr, parent_itable_blkno)) 973 goto fail; 974 } else { 975 /* 976 * If parent and child fall in same inode table block 977 * both should be kept in 1 buffer 978 */ 979 memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz); 980 gd_index--; 981 if (ext4fs_put_metadata(temp_ptr, itable_blkno)) 982 goto fail; 983 } 984 ext4fs_update(); 985 ext4fs_deinit(); 986 987 fs->first_pass_bbmap = 0; 988 fs->curr_blkno = 0; 989 fs->first_pass_ibmap = 0; 990 fs->curr_inode_no = 0; 991 free(inode_buffer); 992 free(g_parent_inode); 993 free(temp_ptr); 994 g_parent_inode = NULL; 995 996 return 0; 997 fail: 998 ext4fs_deinit(); 999 free(inode_buffer); 1000 free(g_parent_inode); 1001 free(temp_ptr); 1002 g_parent_inode = NULL; 1003 1004 return -1; 1005 } 1006 1007 int ext4_write_file(const char *filename, void *buf, loff_t offset, 1008 loff_t len, loff_t *actwrite) 1009 { 1010 int ret; 1011 1012 if (offset != 0) { 1013 printf("** Cannot support non-zero offset **\n"); 1014 return -1; 1015 } 1016 1017 ret = ext4fs_write(filename, buf, len); 1018 if (ret) { 1019 printf("** Error ext4fs_write() **\n"); 1020 goto fail; 1021 } 1022 1023 *actwrite = len; 1024 1025 return 0; 1026 1027 fail: 1028 *actwrite = 0; 1029 1030 return -1; 1031 } 1032