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