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>
7 * ext4ls and ext4load : Based on ext2 ls and load support in Uboot.
8 * Ext4 read optimization taken from Open-Moko
12 * esd gmbh <www.esd-electronics.com>
13 * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
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.
19 * ext4write : Based on generic ext4 protocol.
21 * SPDX-License-Identifier: GPL-2.0+
27 #include <linux/stat.h>
29 #include "ext4_common.h"
31 static inline void ext4fs_sb_free_inodes_inc(struct ext2_sblock *sb)
33 sb->free_inodes = cpu_to_le32(le32_to_cpu(sb->free_inodes) + 1);
36 static inline void ext4fs_sb_free_blocks_inc(struct ext2_sblock *sb)
38 sb->free_blocks = cpu_to_le32(le32_to_cpu(sb->free_blocks) + 1);
41 static inline void ext4fs_bg_free_inodes_inc(struct ext2_block_group *bg)
43 bg->free_inodes = cpu_to_le16(le16_to_cpu(bg->free_inodes) + 1);
46 static inline void ext4fs_bg_free_blocks_inc(struct ext2_block_group *bg)
48 bg->free_blocks = cpu_to_le16(le16_to_cpu(bg->free_blocks) + 1);
51 static void ext4fs_update(void)
54 ext4fs_update_journal();
55 struct ext_filesystem *fs = get_fs();
57 /* update super block */
58 put_ext4((uint64_t)(SUPERBLOCK_SIZE),
59 (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
61 /* update block groups */
62 for (i = 0; i < fs->no_blkgrp; i++) {
63 fs->bgd[i].bg_checksum = cpu_to_le16(ext4fs_checksum_update(i));
64 put_ext4((uint64_t)le32_to_cpu(fs->bgd[i].block_id) * fs->blksz,
65 fs->blk_bmaps[i], fs->blksz);
68 /* update inode table groups */
69 for (i = 0; i < fs->no_blkgrp; i++) {
70 put_ext4((uint64_t)le32_to_cpu(fs->bgd[i].inode_id) * fs->blksz,
71 fs->inode_bmaps[i], fs->blksz);
74 /* update the block group descriptor table */
75 put_ext4((uint64_t)((uint64_t)fs->gdtable_blkno * (uint64_t)fs->blksz),
76 (struct ext2_block_group *)fs->gdtable,
77 (fs->blksz * fs->no_blk_pergdt));
79 ext4fs_dump_metadata();
85 int ext4fs_get_bgdtable(void)
89 struct ext_filesystem *fs = get_fs();
90 grp_desc_size = sizeof(struct ext2_block_group);
91 fs->no_blk_pergdt = (fs->no_blkgrp * grp_desc_size) / fs->blksz;
92 if ((fs->no_blkgrp * grp_desc_size) % fs->blksz)
95 /* allocate memory for gdtable */
96 fs->gdtable = zalloc(fs->blksz * fs->no_blk_pergdt);
99 /* read the group descriptor table */
100 status = ext4fs_devread((lbaint_t)fs->gdtable_blkno * fs->sect_perblk,
101 0, fs->blksz * fs->no_blk_pergdt, fs->gdtable);
105 if (ext4fs_log_gdt(fs->gdtable)) {
106 printf("Error in ext4fs_log_gdt\n");
118 static void delete_single_indirect_block(struct ext2_inode *inode)
120 struct ext2_block_group *bgd = NULL;
121 static int prev_bg_bmap_idx = -1;
126 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
127 struct ext_filesystem *fs = get_fs();
128 char *journal_buffer = zalloc(fs->blksz);
129 if (!journal_buffer) {
130 printf("No memory\n");
133 /* get block group descriptor table */
134 bgd = (struct ext2_block_group *)fs->gdtable;
136 /* deleting the single indirect block associated with inode */
137 if (inode->b.blocks.indir_block != 0) {
138 blknr = le32_to_cpu(inode->b.blocks.indir_block);
139 debug("SIPB releasing %u\n", blknr);
140 bg_idx = blknr / blk_per_grp;
141 if (fs->blksz == 1024) {
142 remainder = blknr % blk_per_grp;
146 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
147 ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
148 ext4fs_sb_free_blocks_inc(fs->sb);
150 if (prev_bg_bmap_idx != bg_idx) {
151 status = ext4fs_devread(
152 (lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
153 fs->sect_perblk, 0, fs->blksz,
157 if (ext4fs_log_journal
158 (journal_buffer, le32_to_cpu(bgd[bg_idx].block_id)))
160 prev_bg_bmap_idx = bg_idx;
164 free(journal_buffer);
167 static void delete_double_indirect_block(struct ext2_inode *inode)
171 static int prev_bg_bmap_idx = -1;
175 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
176 __le32 *di_buffer = NULL;
177 void *dib_start_addr = NULL;
178 struct ext2_block_group *bgd = NULL;
179 struct ext_filesystem *fs = get_fs();
180 char *journal_buffer = zalloc(fs->blksz);
181 if (!journal_buffer) {
182 printf("No memory\n");
185 /* get the block group descriptor table */
186 bgd = (struct ext2_block_group *)fs->gdtable;
188 if (inode->b.blocks.double_indir_block != 0) {
189 di_buffer = zalloc(fs->blksz);
191 printf("No memory\n");
194 dib_start_addr = di_buffer;
195 blknr = le32_to_cpu(inode->b.blocks.double_indir_block);
196 status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
197 fs->blksz, (char *)di_buffer);
198 for (i = 0; i < fs->blksz / sizeof(int); i++) {
202 debug("DICB releasing %u\n", *di_buffer);
203 bg_idx = le32_to_cpu(*di_buffer) / blk_per_grp;
204 if (fs->blksz == 1024) {
205 remainder = le32_to_cpu(*di_buffer) % blk_per_grp;
209 ext4fs_reset_block_bmap(le32_to_cpu(*di_buffer),
210 fs->blk_bmaps[bg_idx], bg_idx);
212 ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
213 ext4fs_sb_free_blocks_inc(fs->sb);
215 if (prev_bg_bmap_idx != bg_idx) {
216 status = ext4fs_devread(
217 (lbaint_t)le32_to_cpu(bgd[bg_idx].block_id)
218 * fs->sect_perblk, 0,
224 if (ext4fs_log_journal(journal_buffer,
225 le32_to_cpu(bgd[bg_idx].block_id)))
227 prev_bg_bmap_idx = bg_idx;
231 /* removing the parent double indirect block */
232 blknr = le32_to_cpu(inode->b.blocks.double_indir_block);
233 bg_idx = blknr / blk_per_grp;
234 if (fs->blksz == 1024) {
235 remainder = blknr % blk_per_grp;
239 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
240 ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
241 ext4fs_sb_free_blocks_inc(fs->sb);
243 if (prev_bg_bmap_idx != bg_idx) {
244 memset(journal_buffer, '\0', fs->blksz);
245 status = ext4fs_devread((lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
246 fs->sect_perblk, 0, fs->blksz,
251 if (ext4fs_log_journal(journal_buffer,
252 le32_to_cpu(bgd[bg_idx].block_id)))
254 prev_bg_bmap_idx = bg_idx;
256 debug("DIPB releasing %d\n", blknr);
259 free(dib_start_addr);
260 free(journal_buffer);
263 static void delete_triple_indirect_block(struct ext2_inode *inode)
267 static int prev_bg_bmap_idx = -1;
271 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
272 __le32 *tigp_buffer = NULL;
273 void *tib_start_addr = NULL;
274 __le32 *tip_buffer = NULL;
275 void *tipb_start_addr = NULL;
276 struct ext2_block_group *bgd = NULL;
277 struct ext_filesystem *fs = get_fs();
278 char *journal_buffer = zalloc(fs->blksz);
279 if (!journal_buffer) {
280 printf("No memory\n");
283 /* get block group descriptor table */
284 bgd = (struct ext2_block_group *)fs->gdtable;
286 if (inode->b.blocks.triple_indir_block != 0) {
287 tigp_buffer = zalloc(fs->blksz);
289 printf("No memory\n");
292 tib_start_addr = tigp_buffer;
293 blknr = le32_to_cpu(inode->b.blocks.triple_indir_block);
294 status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
295 fs->blksz, (char *)tigp_buffer);
296 for (i = 0; i < fs->blksz / sizeof(int); i++) {
297 if (*tigp_buffer == 0)
299 debug("tigp buffer releasing %u\n", *tigp_buffer);
301 tip_buffer = zalloc(fs->blksz);
304 tipb_start_addr = tip_buffer;
305 status = ext4fs_devread((lbaint_t)le32_to_cpu(*tigp_buffer) *
306 fs->sect_perblk, 0, fs->blksz,
308 for (j = 0; j < fs->blksz / sizeof(int); j++) {
309 if (le32_to_cpu(*tip_buffer) == 0)
311 bg_idx = le32_to_cpu(*tip_buffer) / blk_per_grp;
312 if (fs->blksz == 1024) {
313 remainder = le32_to_cpu(*tip_buffer) % blk_per_grp;
318 ext4fs_reset_block_bmap(le32_to_cpu(*tip_buffer),
319 fs->blk_bmaps[bg_idx],
323 ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
324 ext4fs_sb_free_blocks_inc(fs->sb);
326 if (prev_bg_bmap_idx != bg_idx) {
329 (lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
336 if (ext4fs_log_journal(journal_buffer,
337 le32_to_cpu(bgd[bg_idx].block_id)))
339 prev_bg_bmap_idx = bg_idx;
342 free(tipb_start_addr);
343 tipb_start_addr = NULL;
346 * removing the grand parent blocks
347 * which is connected to inode
349 bg_idx = le32_to_cpu(*tigp_buffer) / blk_per_grp;
350 if (fs->blksz == 1024) {
351 remainder = le32_to_cpu(*tigp_buffer) % blk_per_grp;
355 ext4fs_reset_block_bmap(le32_to_cpu(*tigp_buffer),
356 fs->blk_bmaps[bg_idx], bg_idx);
359 ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
360 ext4fs_sb_free_blocks_inc(fs->sb);
362 if (prev_bg_bmap_idx != bg_idx) {
363 memset(journal_buffer, '\0', fs->blksz);
366 (lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
368 fs->blksz, journal_buffer);
372 if (ext4fs_log_journal(journal_buffer,
373 le32_to_cpu(bgd[bg_idx].block_id)))
375 prev_bg_bmap_idx = bg_idx;
379 /* removing the grand parent triple indirect block */
380 blknr = le32_to_cpu(inode->b.blocks.triple_indir_block);
381 bg_idx = blknr / blk_per_grp;
382 if (fs->blksz == 1024) {
383 remainder = blknr % blk_per_grp;
387 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
388 ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
389 ext4fs_sb_free_blocks_inc(fs->sb);
391 if (prev_bg_bmap_idx != bg_idx) {
392 memset(journal_buffer, '\0', fs->blksz);
393 status = ext4fs_devread(
394 (lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
395 fs->sect_perblk, 0, fs->blksz,
400 if (ext4fs_log_journal(journal_buffer,
401 le32_to_cpu(bgd[bg_idx].block_id)))
403 prev_bg_bmap_idx = bg_idx;
405 debug("tigp buffer itself releasing %d\n", blknr);
408 free(tib_start_addr);
409 free(tipb_start_addr);
410 free(journal_buffer);
413 static int ext4fs_delete_file(int inodeno)
415 struct ext2_inode inode;
422 char *read_buffer = NULL;
423 char *start_block_address = NULL;
426 static int prev_bg_bmap_idx = -1;
427 unsigned int inodes_per_block;
430 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
431 uint32_t inode_per_grp = le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
432 struct ext2_inode *inode_buffer = NULL;
433 struct ext2_block_group *bgd = NULL;
434 struct ext_filesystem *fs = get_fs();
435 char *journal_buffer = zalloc(fs->blksz);
438 /* get the block group descriptor table */
439 bgd = (struct ext2_block_group *)fs->gdtable;
440 status = ext4fs_read_inode(ext4fs_root, inodeno, &inode);
444 /* read the block no allocated to a file */
445 no_blocks = le32_to_cpu(inode.size) / fs->blksz;
446 if (le32_to_cpu(inode.size) % fs->blksz)
449 if (le32_to_cpu(inode.flags) & EXT4_EXTENTS_FL) {
450 /* FIXME delete extent index blocks, i.e. eh_depth >= 1 */
451 struct ext4_extent_header *eh =
452 (struct ext4_extent_header *)
453 inode.b.blocks.dir_blocks;
454 debug("del: dep=%d entries=%d\n", eh->eh_depth, eh->eh_entries);
456 delete_single_indirect_block(&inode);
457 delete_double_indirect_block(&inode);
458 delete_triple_indirect_block(&inode);
461 /* release data blocks */
462 for (i = 0; i < no_blocks; i++) {
463 blknr = read_allocated_block(&inode, i);
468 bg_idx = blknr / blk_per_grp;
469 if (fs->blksz == 1024) {
470 remainder = blknr % blk_per_grp;
474 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx],
476 debug("EXT4 Block releasing %ld: %d\n", blknr, bg_idx);
478 ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
479 ext4fs_sb_free_blocks_inc(fs->sb);
481 if (prev_bg_bmap_idx != bg_idx) {
482 uint32_t bgd_blknr = le32_to_cpu(bgd[bg_idx].block_id);
483 status = ext4fs_devread((lbaint_t)bgd_blknr *
489 if (ext4fs_log_journal(journal_buffer, bgd_blknr))
491 prev_bg_bmap_idx = bg_idx;
496 /* from the inode no to blockno */
497 inodes_per_block = fs->blksz / fs->inodesz;
498 ibmap_idx = inodeno / inode_per_grp;
500 /* get the block no */
502 blkno = le32_to_cpu(bgd[ibmap_idx].inode_table_id) +
503 (inodeno % inode_per_grp) / inodes_per_block;
505 /* get the offset of the inode */
506 blkoff = ((inodeno) % inodes_per_block) * fs->inodesz;
508 /* read the block no containing the inode */
509 read_buffer = zalloc(fs->blksz);
512 start_block_address = read_buffer;
513 status = ext4fs_devread((lbaint_t)blkno * fs->sect_perblk,
514 0, fs->blksz, read_buffer);
518 if (ext4fs_log_journal(read_buffer, blkno))
521 read_buffer = read_buffer + blkoff;
522 inode_buffer = (struct ext2_inode *)read_buffer;
523 memset(inode_buffer, '\0', fs->inodesz);
525 /* write the inode to original position in inode table */
526 if (ext4fs_put_metadata(start_block_address, blkno))
529 /* update the respective inode bitmaps */
531 ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx);
532 ext4fs_bg_free_inodes_inc(&bgd[ibmap_idx]);
533 ext4fs_sb_free_inodes_inc(fs->sb);
535 memset(journal_buffer, '\0', fs->blksz);
536 status = ext4fs_devread((lbaint_t)le32_to_cpu(bgd[ibmap_idx].inode_id) *
537 fs->sect_perblk, 0, fs->blksz, journal_buffer);
540 if (ext4fs_log_journal(journal_buffer, le32_to_cpu(bgd[ibmap_idx].inode_id)))
545 ext4fs_reinit_global();
547 if (ext4fs_init() != 0) {
548 printf("error in File System init\n");
552 free(start_block_address);
553 free(journal_buffer);
557 free(start_block_address);
558 free(journal_buffer);
563 int ext4fs_init(void)
567 uint32_t real_free_blocks = 0;
568 struct ext_filesystem *fs = get_fs();
571 fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root);
572 fs->sect_perblk = fs->blksz >> fs->dev_desc->log2blksz;
574 /* get the superblock */
575 fs->sb = zalloc(SUPERBLOCK_SIZE);
578 if (!ext4_read_superblock((char *)fs->sb))
582 if (ext4fs_init_journal())
585 /* get total no of blockgroups */
586 fs->no_blkgrp = (uint32_t)ext4fs_div_roundup(
587 le32_to_cpu(ext4fs_root->sblock.total_blocks)
588 - le32_to_cpu(ext4fs_root->sblock.first_data_block),
589 le32_to_cpu(ext4fs_root->sblock.blocks_per_group));
591 /* get the block group descriptor table */
592 fs->gdtable_blkno = ((EXT2_MIN_BLOCK_SIZE == fs->blksz) + 1);
593 if (ext4fs_get_bgdtable() == -1) {
594 printf("Error in getting the block group descriptor table\n");
597 fs->bgd = (struct ext2_block_group *)fs->gdtable;
599 /* load all the available bitmap block of the partition */
600 fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *));
603 for (i = 0; i < fs->no_blkgrp; i++) {
604 fs->blk_bmaps[i] = zalloc(fs->blksz);
605 if (!fs->blk_bmaps[i])
609 for (i = 0; i < fs->no_blkgrp; i++) {
612 (lbaint_t)le32_to_cpu(fs->bgd[i].block_id) *
614 fs->blksz, (char *)fs->blk_bmaps[i]);
619 /* load all the available inode bitmap of the partition */
620 fs->inode_bmaps = zalloc(fs->no_blkgrp * sizeof(unsigned char *));
621 if (!fs->inode_bmaps)
623 for (i = 0; i < fs->no_blkgrp; i++) {
624 fs->inode_bmaps[i] = zalloc(fs->blksz);
625 if (!fs->inode_bmaps[i])
629 for (i = 0; i < fs->no_blkgrp; i++) {
630 status = ext4fs_devread(
631 (lbaint_t)le32_to_cpu(fs->bgd[i].inode_id) *
634 (char *)fs->inode_bmaps[i]);
640 * check filesystem consistency with free blocks of file system
641 * some time we observed that superblock freeblocks does not match
642 * with the blockgroups freeblocks when improper
643 * reboot of a linux kernel
645 for (i = 0; i < fs->no_blkgrp; i++)
646 real_free_blocks = real_free_blocks + le16_to_cpu(fs->bgd[i].free_blocks);
647 if (real_free_blocks != le32_to_cpu(fs->sb->free_blocks))
648 fs->sb->free_blocks = cpu_to_le32(real_free_blocks);
657 void ext4fs_deinit(void)
660 struct ext2_inode inode_journal;
661 struct journal_superblock_t *jsb;
663 struct ext_filesystem *fs = get_fs();
664 uint32_t new_feature_incompat;
667 char *temp_buff = zalloc(fs->blksz);
669 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
671 blknr = read_allocated_block(&inode_journal,
672 EXT2_JOURNAL_SUPERBLOCK);
673 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz,
675 jsb = (struct journal_superblock_t *)temp_buff;
677 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz),
678 (struct journal_superblock_t *)temp_buff, fs->blksz);
681 ext4fs_free_journal();
683 /* get the superblock */
684 ext4_read_superblock((char *)fs->sb);
685 new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat);
686 new_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
687 fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat);
688 put_ext4((uint64_t)(SUPERBLOCK_SIZE),
689 (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
694 for (i = 0; i < fs->no_blkgrp; i++) {
695 free(fs->blk_bmaps[i]);
696 fs->blk_bmaps[i] = NULL;
699 fs->blk_bmaps = NULL;
702 if (fs->inode_bmaps) {
703 for (i = 0; i < fs->no_blkgrp; i++) {
704 free(fs->inode_bmaps[i]);
705 fs->inode_bmaps[i] = NULL;
707 free(fs->inode_bmaps);
708 fs->inode_bmaps = NULL;
716 * reinitiliazed the global inode and
717 * block bitmap first execution check variables
719 fs->first_pass_ibmap = 0;
720 fs->first_pass_bbmap = 0;
721 fs->curr_inode_no = 0;
726 * Write data to filesystem blocks. Uses same optimization for
727 * contigous sectors as ext4fs_read_file
729 static int ext4fs_write_file(struct ext2_inode *file_inode,
730 int pos, unsigned int len, char *buf)
734 uint32_t filesize = le32_to_cpu(file_inode->size);
735 struct ext_filesystem *fs = get_fs();
736 int log2blksz = fs->dev_desc->log2blksz;
737 int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz;
738 int previous_block_number = -1;
739 int delayed_start = 0;
740 int delayed_extent = 0;
741 int delayed_next = 0;
742 char *delayed_buf = NULL;
744 /* Adjust len so it we can't read past the end of the file. */
748 blockcnt = ((len + pos) + fs->blksz - 1) / fs->blksz;
750 for (i = pos / fs->blksz; i < blockcnt; i++) {
752 int blockend = fs->blksz;
754 blknr = read_allocated_block(file_inode, i);
758 blknr = blknr << log2_fs_blocksize;
761 if (previous_block_number != -1) {
762 if (delayed_next == blknr) {
763 delayed_extent += blockend;
764 delayed_next += blockend >> log2blksz;
767 ((uint64_t)delayed_start << log2blksz),
769 (uint32_t) delayed_extent);
770 previous_block_number = blknr;
771 delayed_start = blknr;
772 delayed_extent = blockend;
774 delayed_next = blknr +
775 (blockend >> log2blksz);
778 previous_block_number = blknr;
779 delayed_start = blknr;
780 delayed_extent = blockend;
782 delayed_next = blknr +
783 (blockend >> log2blksz);
786 if (previous_block_number != -1) {
788 put_ext4((uint64_t) ((uint64_t)delayed_start <<
791 (uint32_t) delayed_extent);
792 previous_block_number = -1;
794 memset(buf, 0, fs->blksz - skipfirst);
796 buf += fs->blksz - skipfirst;
798 if (previous_block_number != -1) {
800 put_ext4((uint64_t) ((uint64_t)delayed_start << log2blksz),
801 delayed_buf, (uint32_t) delayed_extent);
802 previous_block_number = -1;
808 int ext4fs_write(const char *fname, unsigned char *buffer,
809 unsigned long sizebytes)
812 struct ext2_inode *file_inode = NULL;
813 unsigned char *inode_buffer = NULL;
816 time_t timestamp = 0;
818 uint64_t bytes_reqd_for_file;
819 unsigned int blks_reqd_for_file;
820 unsigned int blocks_remaining;
821 int existing_file_inodeno;
822 char *temp_ptr = NULL;
823 long int itable_blkno;
824 long int parent_itable_blkno;
826 struct ext2_sblock *sblock = &(ext4fs_root->sblock);
827 unsigned int inodes_per_block;
828 unsigned int ibmap_idx;
829 struct ext_filesystem *fs = get_fs();
830 ALLOC_CACHE_ALIGN_BUFFER(char, filename, 256);
831 memset(filename, 0x00, 256);
833 g_parent_inode = zalloc(fs->inodesz);
837 if (ext4fs_init() != 0) {
838 printf("error in File System init\n");
841 inodes_per_block = fs->blksz / fs->inodesz;
842 parent_inodeno = ext4fs_get_parent_inode_num(fname, filename, F_FILE);
843 if (parent_inodeno == -1)
845 if (ext4fs_iget(parent_inodeno, g_parent_inode))
847 /* do not mess up a directory using hash trees */
848 if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) {
849 printf("hash tree directory\n");
852 /* check if the filename is already present in root */
853 existing_file_inodeno = ext4fs_filename_unlink(filename);
854 if (existing_file_inodeno != -1) {
855 ret = ext4fs_delete_file(existing_file_inodeno);
856 fs->first_pass_bbmap = 0;
859 fs->first_pass_ibmap = 0;
860 fs->curr_inode_no = 0;
864 /* calucalate how many blocks required */
865 bytes_reqd_for_file = sizebytes;
866 blks_reqd_for_file = lldiv(bytes_reqd_for_file, fs->blksz);
867 if (do_div(bytes_reqd_for_file, fs->blksz) != 0) {
868 blks_reqd_for_file++;
869 debug("total bytes for a file %u\n", blks_reqd_for_file);
871 blocks_remaining = blks_reqd_for_file;
872 /* test for available space in partition */
873 if (le32_to_cpu(fs->sb->free_blocks) < blks_reqd_for_file) {
874 printf("Not enough space on partition !!!\n");
878 inodeno = ext4fs_update_parent_dentry(filename, FILETYPE_REG);
881 /* prepare file inode */
882 inode_buffer = zalloc(fs->inodesz);
885 file_inode = (struct ext2_inode *)inode_buffer;
886 file_inode->mode = cpu_to_le16(S_IFREG | S_IRWXU |
887 S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH);
888 /* ToDo: Update correct time */
889 file_inode->mtime = cpu_to_le32(timestamp);
890 file_inode->atime = cpu_to_le32(timestamp);
891 file_inode->ctime = cpu_to_le32(timestamp);
892 file_inode->nlinks = cpu_to_le16(1);
893 file_inode->size = cpu_to_le32(sizebytes);
895 /* Allocate data blocks */
896 ext4fs_allocate_blocks(file_inode, blocks_remaining,
897 &blks_reqd_for_file);
898 file_inode->blockcnt = cpu_to_le32((blks_reqd_for_file * fs->blksz) >>
899 fs->dev_desc->log2blksz);
901 temp_ptr = zalloc(fs->blksz);
904 ibmap_idx = inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
906 itable_blkno = le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) +
907 (inodeno % le32_to_cpu(sblock->inodes_per_group)) /
909 blkoff = (inodeno % inodes_per_block) * fs->inodesz;
910 ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz,
912 if (ext4fs_log_journal(temp_ptr, itable_blkno))
915 memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz);
916 if (ext4fs_put_metadata(temp_ptr, itable_blkno))
918 /* copy the file content into data blocks */
919 if (ext4fs_write_file(file_inode, 0, sizebytes, (char *)buffer) == -1) {
920 printf("Error in copying content\n");
921 /* FIXME: Deallocate data blocks */
924 ibmap_idx = parent_inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
926 parent_itable_blkno = le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) +
928 le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
929 blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz;
930 if (parent_itable_blkno != itable_blkno) {
931 memset(temp_ptr, '\0', fs->blksz);
932 ext4fs_devread((lbaint_t)parent_itable_blkno * fs->sect_perblk,
933 0, fs->blksz, temp_ptr);
934 if (ext4fs_log_journal(temp_ptr, parent_itable_blkno))
937 memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz);
938 if (ext4fs_put_metadata(temp_ptr, parent_itable_blkno))
942 * If parent and child fall in same inode table block
943 * both should be kept in 1 buffer
945 memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz);
947 if (ext4fs_put_metadata(temp_ptr, itable_blkno))
953 fs->first_pass_bbmap = 0;
955 fs->first_pass_ibmap = 0;
956 fs->curr_inode_no = 0;
958 free(g_parent_inode);
960 g_parent_inode = NULL;
966 free(g_parent_inode);
968 g_parent_inode = NULL;
973 int ext4_write_file(const char *filename, void *buf, loff_t offset,
974 loff_t len, loff_t *actwrite)
979 printf("** Cannot support non-zero offset **\n");
983 ret = ext4fs_write(filename, buf, len);
985 printf("** Error ext4fs_write() **\n");