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();
56 struct ext2_block_group *bgd = NULL;
58 /* update super block */
59 put_ext4((uint64_t)(SUPERBLOCK_SIZE),
60 (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
62 /* update block bitmaps */
63 for (i = 0; i < fs->no_blkgrp; i++) {
64 bgd = ext4fs_get_group_descriptor(fs, i);
65 bgd->bg_checksum = cpu_to_le16(ext4fs_checksum_update(i));
66 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
67 put_ext4(b_bitmap_blk * fs->blksz,
68 fs->blk_bmaps[i], fs->blksz);
71 /* update inode bitmaps */
72 for (i = 0; i < fs->no_blkgrp; i++) {
73 bgd = ext4fs_get_group_descriptor(fs, i);
74 uint64_t i_bitmap_blk = ext4fs_bg_get_inode_id(bgd, fs);
75 put_ext4(i_bitmap_blk * fs->blksz,
76 fs->inode_bmaps[i], fs->blksz);
79 /* update the block group descriptor table */
80 put_ext4((uint64_t)((uint64_t)fs->gdtable_blkno * (uint64_t)fs->blksz),
81 (struct ext2_block_group *)fs->gdtable,
82 (fs->blksz * fs->no_blk_pergdt));
84 ext4fs_dump_metadata();
90 int ext4fs_get_bgdtable(void)
93 struct ext_filesystem *fs = get_fs();
94 int gdsize_total = ROUND(fs->no_blkgrp * fs->gdsize, fs->blksz);
95 fs->no_blk_pergdt = gdsize_total / fs->blksz;
97 /* allocate memory for gdtable */
98 fs->gdtable = zalloc(gdsize_total);
101 /* read the group descriptor table */
102 status = ext4fs_devread((lbaint_t)fs->gdtable_blkno * fs->sect_perblk,
103 0, fs->blksz * fs->no_blk_pergdt, fs->gdtable);
107 if (ext4fs_log_gdt(fs->gdtable)) {
108 printf("Error in ext4fs_log_gdt\n");
120 static void delete_single_indirect_block(struct ext2_inode *inode)
122 struct ext2_block_group *bgd = NULL;
123 static int prev_bg_bmap_idx = -1;
128 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
129 struct ext_filesystem *fs = get_fs();
130 char *journal_buffer = zalloc(fs->blksz);
131 if (!journal_buffer) {
132 printf("No memory\n");
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 /* get block group descriptor table */
148 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
149 ext4fs_bg_free_blocks_inc(bgd);
150 ext4fs_sb_free_blocks_inc(fs->sb);
152 if (prev_bg_bmap_idx != bg_idx) {
153 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
154 status = ext4fs_devread(
155 b_bitmap_blk * fs->sect_perblk,
156 0, fs->blksz, journal_buffer);
159 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
161 prev_bg_bmap_idx = bg_idx;
165 free(journal_buffer);
168 static void delete_double_indirect_block(struct ext2_inode *inode)
172 static int prev_bg_bmap_idx = -1;
176 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
177 __le32 *di_buffer = NULL;
178 void *dib_start_addr = NULL;
179 struct ext2_block_group *bgd = NULL;
180 struct ext_filesystem *fs = get_fs();
181 char *journal_buffer = zalloc(fs->blksz);
182 if (!journal_buffer) {
183 printf("No memory\n");
187 if (inode->b.blocks.double_indir_block != 0) {
188 di_buffer = zalloc(fs->blksz);
190 printf("No memory\n");
193 dib_start_addr = di_buffer;
194 blknr = le32_to_cpu(inode->b.blocks.double_indir_block);
195 status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
196 fs->blksz, (char *)di_buffer);
197 for (i = 0; i < fs->blksz / sizeof(int); i++) {
201 debug("DICB releasing %u\n", *di_buffer);
202 bg_idx = le32_to_cpu(*di_buffer) / blk_per_grp;
203 if (fs->blksz == 1024) {
204 remainder = le32_to_cpu(*di_buffer) % blk_per_grp;
208 /* get block group descriptor table */
209 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
210 ext4fs_reset_block_bmap(le32_to_cpu(*di_buffer),
211 fs->blk_bmaps[bg_idx], bg_idx);
213 ext4fs_bg_free_blocks_inc(bgd);
214 ext4fs_sb_free_blocks_inc(fs->sb);
216 if (prev_bg_bmap_idx != bg_idx) {
217 uint64_t b_bitmap_blk =
218 ext4fs_bg_get_block_id(bgd, fs);
219 status = ext4fs_devread(b_bitmap_blk
220 * fs->sect_perblk, 0,
226 if (ext4fs_log_journal(journal_buffer,
229 prev_bg_bmap_idx = bg_idx;
233 /* removing the parent double indirect block */
234 blknr = le32_to_cpu(inode->b.blocks.double_indir_block);
235 bg_idx = blknr / blk_per_grp;
236 if (fs->blksz == 1024) {
237 remainder = blknr % blk_per_grp;
241 /* get block group descriptor table */
242 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
243 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
244 ext4fs_bg_free_blocks_inc(bgd);
245 ext4fs_sb_free_blocks_inc(fs->sb);
247 if (prev_bg_bmap_idx != bg_idx) {
248 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
249 status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk,
250 0, fs->blksz, journal_buffer);
254 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
256 prev_bg_bmap_idx = bg_idx;
258 debug("DIPB releasing %d\n", blknr);
261 free(dib_start_addr);
262 free(journal_buffer);
265 static void delete_triple_indirect_block(struct ext2_inode *inode)
269 static int prev_bg_bmap_idx = -1;
273 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
274 __le32 *tigp_buffer = NULL;
275 void *tib_start_addr = NULL;
276 __le32 *tip_buffer = NULL;
277 void *tipb_start_addr = NULL;
278 struct ext2_block_group *bgd = NULL;
279 struct ext_filesystem *fs = get_fs();
280 char *journal_buffer = zalloc(fs->blksz);
281 if (!journal_buffer) {
282 printf("No memory\n");
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 /* get block group descriptor table */
324 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
325 ext4fs_bg_free_blocks_inc(bgd);
326 ext4fs_sb_free_blocks_inc(fs->sb);
328 if (prev_bg_bmap_idx != bg_idx) {
329 uint64_t b_bitmap_blk =
330 ext4fs_bg_get_block_id(bgd, fs);
340 if (ext4fs_log_journal(journal_buffer,
343 prev_bg_bmap_idx = bg_idx;
346 free(tipb_start_addr);
347 tipb_start_addr = NULL;
350 * removing the grand parent blocks
351 * which is connected to inode
353 bg_idx = le32_to_cpu(*tigp_buffer) / blk_per_grp;
354 if (fs->blksz == 1024) {
355 remainder = le32_to_cpu(*tigp_buffer) % blk_per_grp;
359 ext4fs_reset_block_bmap(le32_to_cpu(*tigp_buffer),
360 fs->blk_bmaps[bg_idx], bg_idx);
363 /* get block group descriptor table */
364 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
365 ext4fs_bg_free_blocks_inc(bgd);
366 ext4fs_sb_free_blocks_inc(fs->sb);
368 if (prev_bg_bmap_idx != bg_idx) {
369 uint64_t b_bitmap_blk =
370 ext4fs_bg_get_block_id(bgd, fs);
371 memset(journal_buffer, '\0', fs->blksz);
372 status = ext4fs_devread(b_bitmap_blk *
379 if (ext4fs_log_journal(journal_buffer,
382 prev_bg_bmap_idx = bg_idx;
386 /* removing the grand parent triple indirect block */
387 blknr = le32_to_cpu(inode->b.blocks.triple_indir_block);
388 bg_idx = blknr / blk_per_grp;
389 if (fs->blksz == 1024) {
390 remainder = blknr % blk_per_grp;
394 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
395 /* get block group descriptor table */
396 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
397 ext4fs_bg_free_blocks_inc(bgd);
398 ext4fs_sb_free_blocks_inc(fs->sb);
400 if (prev_bg_bmap_idx != bg_idx) {
401 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
402 status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk,
403 0, fs->blksz, journal_buffer);
407 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
409 prev_bg_bmap_idx = bg_idx;
411 debug("tigp buffer itself releasing %d\n", blknr);
414 free(tib_start_addr);
415 free(tipb_start_addr);
416 free(journal_buffer);
419 static int ext4fs_delete_file(int inodeno)
421 struct ext2_inode inode;
428 char *read_buffer = NULL;
429 char *start_block_address = NULL;
432 static int prev_bg_bmap_idx = -1;
433 unsigned int inodes_per_block;
436 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
437 uint32_t inode_per_grp = le32_to_cpu(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);
444 status = ext4fs_read_inode(ext4fs_root, inodeno, &inode);
448 /* read the block no allocated to a file */
449 no_blocks = le32_to_cpu(inode.size) / fs->blksz;
450 if (le32_to_cpu(inode.size) % fs->blksz)
453 if (le32_to_cpu(inode.flags) & EXT4_EXTENTS_FL) {
454 /* FIXME delete extent index blocks, i.e. eh_depth >= 1 */
455 struct ext4_extent_header *eh =
456 (struct ext4_extent_header *)
457 inode.b.blocks.dir_blocks;
458 debug("del: dep=%d entries=%d\n", eh->eh_depth, eh->eh_entries);
460 delete_single_indirect_block(&inode);
461 delete_double_indirect_block(&inode);
462 delete_triple_indirect_block(&inode);
465 /* release data blocks */
466 for (i = 0; i < no_blocks; i++) {
467 blknr = read_allocated_block(&inode, i);
472 bg_idx = blknr / blk_per_grp;
473 if (fs->blksz == 1024) {
474 remainder = blknr % blk_per_grp;
478 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx],
480 debug("EXT4 Block releasing %ld: %d\n", blknr, bg_idx);
482 /* get block group descriptor table */
483 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
484 ext4fs_bg_free_blocks_inc(bgd);
485 ext4fs_sb_free_blocks_inc(fs->sb);
487 if (prev_bg_bmap_idx != bg_idx) {
488 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
489 status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk,
494 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
496 prev_bg_bmap_idx = bg_idx;
501 /* from the inode no to blockno */
502 inodes_per_block = fs->blksz / fs->inodesz;
503 ibmap_idx = inodeno / inode_per_grp;
505 /* get the block no */
507 /* get block group descriptor table */
508 bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
509 blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
510 (inodeno % inode_per_grp) / inodes_per_block;
512 /* get the offset of the inode */
513 blkoff = ((inodeno) % inodes_per_block) * fs->inodesz;
515 /* read the block no containing the inode */
516 read_buffer = zalloc(fs->blksz);
519 start_block_address = read_buffer;
520 status = ext4fs_devread((lbaint_t)blkno * fs->sect_perblk,
521 0, fs->blksz, read_buffer);
525 if (ext4fs_log_journal(read_buffer, blkno))
528 read_buffer = read_buffer + blkoff;
529 inode_buffer = (struct ext2_inode *)read_buffer;
530 memset(inode_buffer, '\0', fs->inodesz);
532 /* write the inode to original position in inode table */
533 if (ext4fs_put_metadata(start_block_address, blkno))
536 /* update the respective inode bitmaps */
538 ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx);
539 ext4fs_bg_free_inodes_inc(bgd);
540 ext4fs_sb_free_inodes_inc(fs->sb);
542 memset(journal_buffer, '\0', fs->blksz);
543 status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) *
544 fs->sect_perblk, 0, fs->blksz, journal_buffer);
547 if (ext4fs_log_journal(journal_buffer, ext4fs_bg_get_inode_id(bgd, fs)))
552 ext4fs_reinit_global();
554 if (ext4fs_init() != 0) {
555 printf("error in File System init\n");
559 free(start_block_address);
560 free(journal_buffer);
564 free(start_block_address);
565 free(journal_buffer);
570 int ext4fs_init(void)
574 uint32_t real_free_blocks = 0;
575 struct ext_filesystem *fs = get_fs();
578 fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root);
579 fs->sect_perblk = fs->blksz >> fs->dev_desc->log2blksz;
581 /* get the superblock */
582 fs->sb = zalloc(SUPERBLOCK_SIZE);
585 if (!ext4_read_superblock((char *)fs->sb))
589 if (ext4fs_init_journal())
592 /* get total no of blockgroups */
593 fs->no_blkgrp = (uint32_t)ext4fs_div_roundup(
594 le32_to_cpu(ext4fs_root->sblock.total_blocks)
595 - le32_to_cpu(ext4fs_root->sblock.first_data_block),
596 le32_to_cpu(ext4fs_root->sblock.blocks_per_group));
598 /* get the block group descriptor table */
599 fs->gdtable_blkno = ((EXT2_MIN_BLOCK_SIZE == fs->blksz) + 1);
600 if (ext4fs_get_bgdtable() == -1) {
601 printf("Error in getting the block group descriptor table\n");
605 /* load all the available bitmap block of the partition */
606 fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *));
609 for (i = 0; i < fs->no_blkgrp; i++) {
610 fs->blk_bmaps[i] = zalloc(fs->blksz);
611 if (!fs->blk_bmaps[i])
615 for (i = 0; i < fs->no_blkgrp; i++) {
616 struct ext2_block_group *bgd =
617 ext4fs_get_group_descriptor(fs, i);
618 status = ext4fs_devread(ext4fs_bg_get_block_id(bgd, fs) *
620 fs->blksz, (char *)fs->blk_bmaps[i]);
625 /* load all the available inode bitmap of the partition */
626 fs->inode_bmaps = zalloc(fs->no_blkgrp * sizeof(unsigned char *));
627 if (!fs->inode_bmaps)
629 for (i = 0; i < fs->no_blkgrp; i++) {
630 fs->inode_bmaps[i] = zalloc(fs->blksz);
631 if (!fs->inode_bmaps[i])
635 for (i = 0; i < fs->no_blkgrp; i++) {
636 struct ext2_block_group *bgd =
637 ext4fs_get_group_descriptor(fs, i);
638 status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) *
641 (char *)fs->inode_bmaps[i]);
647 * check filesystem consistency with free blocks of file system
648 * some time we observed that superblock freeblocks does not match
649 * with the blockgroups freeblocks when improper
650 * reboot of a linux kernel
652 for (i = 0; i < fs->no_blkgrp; i++) {
653 struct ext2_block_group *bgd =
654 ext4fs_get_group_descriptor(fs, i);
655 real_free_blocks = real_free_blocks +
656 ext4fs_bg_get_free_blocks(bgd, fs);
658 if (real_free_blocks != ext4fs_sb_get_free_blocks(fs->sb))
659 ext4fs_sb_set_free_blocks(fs->sb, real_free_blocks);
668 void ext4fs_deinit(void)
671 struct ext2_inode inode_journal;
672 struct journal_superblock_t *jsb;
674 struct ext_filesystem *fs = get_fs();
675 uint32_t new_feature_incompat;
678 char *temp_buff = zalloc(fs->blksz);
680 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
682 blknr = read_allocated_block(&inode_journal,
683 EXT2_JOURNAL_SUPERBLOCK);
684 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz,
686 jsb = (struct journal_superblock_t *)temp_buff;
688 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz),
689 (struct journal_superblock_t *)temp_buff, fs->blksz);
692 ext4fs_free_journal();
694 /* get the superblock */
695 ext4_read_superblock((char *)fs->sb);
696 new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat);
697 new_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
698 fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat);
699 put_ext4((uint64_t)(SUPERBLOCK_SIZE),
700 (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
705 for (i = 0; i < fs->no_blkgrp; i++) {
706 free(fs->blk_bmaps[i]);
707 fs->blk_bmaps[i] = NULL;
710 fs->blk_bmaps = NULL;
713 if (fs->inode_bmaps) {
714 for (i = 0; i < fs->no_blkgrp; i++) {
715 free(fs->inode_bmaps[i]);
716 fs->inode_bmaps[i] = NULL;
718 free(fs->inode_bmaps);
719 fs->inode_bmaps = NULL;
726 * reinitiliazed the global inode and
727 * block bitmap first execution check variables
729 fs->first_pass_ibmap = 0;
730 fs->first_pass_bbmap = 0;
731 fs->curr_inode_no = 0;
736 * Write data to filesystem blocks. Uses same optimization for
737 * contigous sectors as ext4fs_read_file
739 static int ext4fs_write_file(struct ext2_inode *file_inode,
740 int pos, unsigned int len, char *buf)
744 uint32_t filesize = le32_to_cpu(file_inode->size);
745 struct ext_filesystem *fs = get_fs();
746 int log2blksz = fs->dev_desc->log2blksz;
747 int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz;
748 int previous_block_number = -1;
749 int delayed_start = 0;
750 int delayed_extent = 0;
751 int delayed_next = 0;
752 char *delayed_buf = NULL;
754 /* Adjust len so it we can't read past the end of the file. */
758 blockcnt = ((len + pos) + fs->blksz - 1) / fs->blksz;
760 for (i = pos / fs->blksz; i < blockcnt; i++) {
762 int blockend = fs->blksz;
764 blknr = read_allocated_block(file_inode, i);
768 blknr = blknr << log2_fs_blocksize;
771 if (previous_block_number != -1) {
772 if (delayed_next == blknr) {
773 delayed_extent += blockend;
774 delayed_next += blockend >> log2blksz;
777 ((uint64_t)delayed_start << log2blksz),
779 (uint32_t) delayed_extent);
780 previous_block_number = blknr;
781 delayed_start = blknr;
782 delayed_extent = blockend;
784 delayed_next = blknr +
785 (blockend >> log2blksz);
788 previous_block_number = blknr;
789 delayed_start = blknr;
790 delayed_extent = blockend;
792 delayed_next = blknr +
793 (blockend >> log2blksz);
796 if (previous_block_number != -1) {
798 put_ext4((uint64_t) ((uint64_t)delayed_start <<
801 (uint32_t) delayed_extent);
802 previous_block_number = -1;
804 memset(buf, 0, fs->blksz - skipfirst);
806 buf += fs->blksz - skipfirst;
808 if (previous_block_number != -1) {
810 put_ext4((uint64_t) ((uint64_t)delayed_start << log2blksz),
811 delayed_buf, (uint32_t) delayed_extent);
812 previous_block_number = -1;
818 int ext4fs_write(const char *fname, unsigned char *buffer,
819 unsigned long sizebytes)
822 struct ext2_inode *file_inode = NULL;
823 unsigned char *inode_buffer = NULL;
826 time_t timestamp = 0;
828 uint64_t bytes_reqd_for_file;
829 unsigned int blks_reqd_for_file;
830 unsigned int blocks_remaining;
831 int existing_file_inodeno;
832 char *temp_ptr = NULL;
833 long int itable_blkno;
834 long int parent_itable_blkno;
836 struct ext2_sblock *sblock = &(ext4fs_root->sblock);
837 unsigned int inodes_per_block;
838 unsigned int ibmap_idx;
839 struct ext2_block_group *bgd = NULL;
840 struct ext_filesystem *fs = get_fs();
841 ALLOC_CACHE_ALIGN_BUFFER(char, filename, 256);
842 memset(filename, 0x00, 256);
844 g_parent_inode = zalloc(fs->inodesz);
848 if (ext4fs_init() != 0) {
849 printf("error in File System init\n");
852 inodes_per_block = fs->blksz / fs->inodesz;
853 parent_inodeno = ext4fs_get_parent_inode_num(fname, filename, F_FILE);
854 if (parent_inodeno == -1)
856 if (ext4fs_iget(parent_inodeno, g_parent_inode))
858 /* do not mess up a directory using hash trees */
859 if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) {
860 printf("hash tree directory\n");
863 /* check if the filename is already present in root */
864 existing_file_inodeno = ext4fs_filename_unlink(filename);
865 if (existing_file_inodeno != -1) {
866 ret = ext4fs_delete_file(existing_file_inodeno);
867 fs->first_pass_bbmap = 0;
870 fs->first_pass_ibmap = 0;
871 fs->curr_inode_no = 0;
875 /* calucalate how many blocks required */
876 bytes_reqd_for_file = sizebytes;
877 blks_reqd_for_file = lldiv(bytes_reqd_for_file, fs->blksz);
878 if (do_div(bytes_reqd_for_file, fs->blksz) != 0) {
879 blks_reqd_for_file++;
880 debug("total bytes for a file %u\n", blks_reqd_for_file);
882 blocks_remaining = blks_reqd_for_file;
883 /* test for available space in partition */
884 if (le32_to_cpu(fs->sb->free_blocks) < blks_reqd_for_file) {
885 printf("Not enough space on partition !!!\n");
889 inodeno = ext4fs_update_parent_dentry(filename, FILETYPE_REG);
892 /* prepare file inode */
893 inode_buffer = zalloc(fs->inodesz);
896 file_inode = (struct ext2_inode *)inode_buffer;
897 file_inode->mode = cpu_to_le16(S_IFREG | S_IRWXU |
898 S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH);
899 /* ToDo: Update correct time */
900 file_inode->mtime = cpu_to_le32(timestamp);
901 file_inode->atime = cpu_to_le32(timestamp);
902 file_inode->ctime = cpu_to_le32(timestamp);
903 file_inode->nlinks = cpu_to_le16(1);
904 file_inode->size = cpu_to_le32(sizebytes);
906 /* Allocate data blocks */
907 ext4fs_allocate_blocks(file_inode, blocks_remaining,
908 &blks_reqd_for_file);
909 file_inode->blockcnt = cpu_to_le32((blks_reqd_for_file * fs->blksz) >>
910 fs->dev_desc->log2blksz);
912 temp_ptr = zalloc(fs->blksz);
915 ibmap_idx = inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
917 bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
918 itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
919 (inodeno % le32_to_cpu(sblock->inodes_per_group)) /
921 blkoff = (inodeno % inodes_per_block) * fs->inodesz;
922 ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz,
924 if (ext4fs_log_journal(temp_ptr, itable_blkno))
927 memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz);
928 if (ext4fs_put_metadata(temp_ptr, itable_blkno))
930 /* copy the file content into data blocks */
931 if (ext4fs_write_file(file_inode, 0, sizebytes, (char *)buffer) == -1) {
932 printf("Error in copying content\n");
933 /* FIXME: Deallocate data blocks */
936 ibmap_idx = parent_inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
938 bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
939 parent_itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
941 le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
942 blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz;
943 if (parent_itable_blkno != itable_blkno) {
944 memset(temp_ptr, '\0', fs->blksz);
945 ext4fs_devread((lbaint_t)parent_itable_blkno * fs->sect_perblk,
946 0, fs->blksz, temp_ptr);
947 if (ext4fs_log_journal(temp_ptr, parent_itable_blkno))
950 memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz);
951 if (ext4fs_put_metadata(temp_ptr, parent_itable_blkno))
955 * If parent and child fall in same inode table block
956 * both should be kept in 1 buffer
958 memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz);
960 if (ext4fs_put_metadata(temp_ptr, itable_blkno))
966 fs->first_pass_bbmap = 0;
968 fs->first_pass_ibmap = 0;
969 fs->curr_inode_no = 0;
971 free(g_parent_inode);
973 g_parent_inode = NULL;
979 free(g_parent_inode);
981 g_parent_inode = NULL;
986 int ext4_write_file(const char *filename, void *buf, loff_t offset,
987 loff_t len, loff_t *actwrite)
992 printf("** Cannot support non-zero offset **\n");
996 ret = ext4fs_write(filename, buf, len);
998 printf("** Error ext4fs_write() **\n");