| /* | |
| * (C) Copyright 2011 - 2012 Samsung Electronics | |
| * EXT4 filesystem implementation in Uboot by | |
| * Uma Shankar <uma.shankar@samsung.com> | |
| * Manjunatha C Achar <a.manjunatha@samsung.com> | |
| * | |
| * ext4ls and ext4load : Based on ext2 ls and load support in Uboot. | |
| * Ext4 read optimization taken from Open-Moko | |
| * Qi bootloader | |
| * | |
| * (C) Copyright 2004 | |
| * esd gmbh <www.esd-electronics.com> | |
| * Reinhard Arlt <reinhard.arlt@esd-electronics.com> | |
| * | |
| * based on code from grub2 fs/ext2.c and fs/fshelp.c by | |
| * GRUB -- GRand Unified Bootloader | |
| * Copyright (C) 2003, 2004 Free Software Foundation, Inc. | |
| * | |
| * ext4write : Based on generic ext4 protocol. | |
| * | |
| * SPDX-License-Identifier: GPL-2.0+ | |
| */ | |
| #include <common.h> | |
| #include <memalign.h> | |
| #include <linux/stat.h> | |
| #include <div64.h> | |
| #include "ext4_common.h" | |
| static inline void ext4fs_sb_free_inodes_inc(struct ext2_sblock *sb) | |
| { | |
| sb->free_inodes = cpu_to_le32(le32_to_cpu(sb->free_inodes) + 1); | |
| } | |
| static inline void ext4fs_sb_free_blocks_inc(struct ext2_sblock *sb) | |
| { | |
| sb->free_blocks = cpu_to_le32(le32_to_cpu(sb->free_blocks) + 1); | |
| } | |
| static inline void ext4fs_bg_free_inodes_inc | |
| (struct ext2_block_group *bg, const struct ext_filesystem *fs) | |
| { | |
| uint32_t free_inodes = le16_to_cpu(bg->free_inodes); | |
| if (fs->gdsize == 64) | |
| free_inodes += le16_to_cpu(bg->free_inodes_high) << 16; | |
| free_inodes++; | |
| bg->free_inodes = cpu_to_le16(free_inodes & 0xffff); | |
| if (fs->gdsize == 64) | |
| bg->free_inodes_high = cpu_to_le16(free_inodes >> 16); | |
| } | |
| static inline void ext4fs_bg_free_blocks_inc | |
| (struct ext2_block_group *bg, const struct ext_filesystem *fs) | |
| { | |
| uint32_t free_blocks = le16_to_cpu(bg->free_blocks); | |
| if (fs->gdsize == 64) | |
| free_blocks += le16_to_cpu(bg->free_blocks_high) << 16; | |
| free_blocks++; | |
| bg->free_blocks = cpu_to_le16(free_blocks & 0xffff); | |
| if (fs->gdsize == 64) | |
| bg->free_blocks_high = cpu_to_le16(free_blocks >> 16); | |
| } | |
| static void ext4fs_update(void) | |
| { | |
| short i; | |
| ext4fs_update_journal(); | |
| struct ext_filesystem *fs = get_fs(); | |
| struct ext2_block_group *bgd = NULL; | |
| /* update super block */ | |
| put_ext4((uint64_t)(SUPERBLOCK_SIZE), | |
| (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE); | |
| /* update block bitmaps */ | |
| for (i = 0; i < fs->no_blkgrp; i++) { | |
| bgd = ext4fs_get_group_descriptor(fs, i); | |
| bgd->bg_checksum = cpu_to_le16(ext4fs_checksum_update(i)); | |
| uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); | |
| put_ext4(b_bitmap_blk * fs->blksz, | |
| fs->blk_bmaps[i], fs->blksz); | |
| } | |
| /* update inode bitmaps */ | |
| for (i = 0; i < fs->no_blkgrp; i++) { | |
| bgd = ext4fs_get_group_descriptor(fs, i); | |
| uint64_t i_bitmap_blk = ext4fs_bg_get_inode_id(bgd, fs); | |
| put_ext4(i_bitmap_blk * fs->blksz, | |
| fs->inode_bmaps[i], fs->blksz); | |
| } | |
| /* update the block group descriptor table */ | |
| put_ext4((uint64_t)((uint64_t)fs->gdtable_blkno * (uint64_t)fs->blksz), | |
| (struct ext2_block_group *)fs->gdtable, | |
| (fs->blksz * fs->no_blk_pergdt)); | |
| ext4fs_dump_metadata(); | |
| gindex = 0; | |
| gd_index = 0; | |
| } | |
| int ext4fs_get_bgdtable(void) | |
| { | |
| int status; | |
| struct ext_filesystem *fs = get_fs(); | |
| int gdsize_total = ROUND(fs->no_blkgrp * fs->gdsize, fs->blksz); | |
| fs->no_blk_pergdt = gdsize_total / fs->blksz; | |
| /* allocate memory for gdtable */ | |
| fs->gdtable = zalloc(gdsize_total); | |
| if (!fs->gdtable) | |
| return -ENOMEM; | |
| /* read the group descriptor table */ | |
| status = ext4fs_devread((lbaint_t)fs->gdtable_blkno * fs->sect_perblk, | |
| 0, fs->blksz * fs->no_blk_pergdt, fs->gdtable); | |
| if (status == 0) | |
| goto fail; | |
| if (ext4fs_log_gdt(fs->gdtable)) { | |
| printf("Error in ext4fs_log_gdt\n"); | |
| return -1; | |
| } | |
| return 0; | |
| fail: | |
| free(fs->gdtable); | |
| fs->gdtable = NULL; | |
| return -1; | |
| } | |
| static void delete_single_indirect_block(struct ext2_inode *inode) | |
| { | |
| struct ext2_block_group *bgd = NULL; | |
| static int prev_bg_bmap_idx = -1; | |
| uint32_t blknr; | |
| int remainder; | |
| int bg_idx; | |
| int status; | |
| uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); | |
| struct ext_filesystem *fs = get_fs(); | |
| char *journal_buffer = zalloc(fs->blksz); | |
| if (!journal_buffer) { | |
| printf("No memory\n"); | |
| return; | |
| } | |
| /* deleting the single indirect block associated with inode */ | |
| if (inode->b.blocks.indir_block != 0) { | |
| blknr = le32_to_cpu(inode->b.blocks.indir_block); | |
| debug("SIPB releasing %u\n", blknr); | |
| bg_idx = blknr / blk_per_grp; | |
| if (fs->blksz == 1024) { | |
| remainder = blknr % blk_per_grp; | |
| if (!remainder) | |
| bg_idx--; | |
| } | |
| ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); | |
| /* get block group descriptor table */ | |
| bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
| ext4fs_bg_free_blocks_inc(bgd, fs); | |
| ext4fs_sb_free_blocks_inc(fs->sb); | |
| /* journal backup */ | |
| if (prev_bg_bmap_idx != bg_idx) { | |
| uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); | |
| status = ext4fs_devread( | |
| b_bitmap_blk * fs->sect_perblk, | |
| 0, fs->blksz, journal_buffer); | |
| if (status == 0) | |
| goto fail; | |
| if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) | |
| goto fail; | |
| prev_bg_bmap_idx = bg_idx; | |
| } | |
| } | |
| fail: | |
| free(journal_buffer); | |
| } | |
| static void delete_double_indirect_block(struct ext2_inode *inode) | |
| { | |
| int i; | |
| short status; | |
| static int prev_bg_bmap_idx = -1; | |
| uint32_t blknr; | |
| int remainder; | |
| int bg_idx; | |
| uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); | |
| __le32 *di_buffer = NULL; | |
| void *dib_start_addr = NULL; | |
| struct ext2_block_group *bgd = NULL; | |
| struct ext_filesystem *fs = get_fs(); | |
| char *journal_buffer = zalloc(fs->blksz); | |
| if (!journal_buffer) { | |
| printf("No memory\n"); | |
| return; | |
| } | |
| if (inode->b.blocks.double_indir_block != 0) { | |
| di_buffer = zalloc(fs->blksz); | |
| if (!di_buffer) { | |
| printf("No memory\n"); | |
| return; | |
| } | |
| dib_start_addr = di_buffer; | |
| blknr = le32_to_cpu(inode->b.blocks.double_indir_block); | |
| status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, | |
| fs->blksz, (char *)di_buffer); | |
| for (i = 0; i < fs->blksz / sizeof(int); i++) { | |
| if (*di_buffer == 0) | |
| break; | |
| debug("DICB releasing %u\n", *di_buffer); | |
| bg_idx = le32_to_cpu(*di_buffer) / blk_per_grp; | |
| if (fs->blksz == 1024) { | |
| remainder = le32_to_cpu(*di_buffer) % blk_per_grp; | |
| if (!remainder) | |
| bg_idx--; | |
| } | |
| /* get block group descriptor table */ | |
| bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
| ext4fs_reset_block_bmap(le32_to_cpu(*di_buffer), | |
| fs->blk_bmaps[bg_idx], bg_idx); | |
| di_buffer++; | |
| ext4fs_bg_free_blocks_inc(bgd, fs); | |
| ext4fs_sb_free_blocks_inc(fs->sb); | |
| /* journal backup */ | |
| if (prev_bg_bmap_idx != bg_idx) { | |
| uint64_t b_bitmap_blk = | |
| ext4fs_bg_get_block_id(bgd, fs); | |
| status = ext4fs_devread(b_bitmap_blk | |
| * fs->sect_perblk, 0, | |
| fs->blksz, | |
| journal_buffer); | |
| if (status == 0) | |
| goto fail; | |
| if (ext4fs_log_journal(journal_buffer, | |
| b_bitmap_blk)) | |
| goto fail; | |
| prev_bg_bmap_idx = bg_idx; | |
| } | |
| } | |
| /* removing the parent double indirect block */ | |
| blknr = le32_to_cpu(inode->b.blocks.double_indir_block); | |
| bg_idx = blknr / blk_per_grp; | |
| if (fs->blksz == 1024) { | |
| remainder = blknr % blk_per_grp; | |
| if (!remainder) | |
| bg_idx--; | |
| } | |
| /* get block group descriptor table */ | |
| bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
| ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); | |
| ext4fs_bg_free_blocks_inc(bgd, fs); | |
| ext4fs_sb_free_blocks_inc(fs->sb); | |
| /* journal backup */ | |
| if (prev_bg_bmap_idx != bg_idx) { | |
| uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); | |
| status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk, | |
| 0, fs->blksz, journal_buffer); | |
| if (status == 0) | |
| goto fail; | |
| if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) | |
| goto fail; | |
| prev_bg_bmap_idx = bg_idx; | |
| } | |
| debug("DIPB releasing %d\n", blknr); | |
| } | |
| fail: | |
| free(dib_start_addr); | |
| free(journal_buffer); | |
| } | |
| static void delete_triple_indirect_block(struct ext2_inode *inode) | |
| { | |
| int i, j; | |
| short status; | |
| static int prev_bg_bmap_idx = -1; | |
| uint32_t blknr; | |
| int remainder; | |
| int bg_idx; | |
| uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); | |
| __le32 *tigp_buffer = NULL; | |
| void *tib_start_addr = NULL; | |
| __le32 *tip_buffer = NULL; | |
| void *tipb_start_addr = NULL; | |
| struct ext2_block_group *bgd = NULL; | |
| struct ext_filesystem *fs = get_fs(); | |
| char *journal_buffer = zalloc(fs->blksz); | |
| if (!journal_buffer) { | |
| printf("No memory\n"); | |
| return; | |
| } | |
| if (inode->b.blocks.triple_indir_block != 0) { | |
| tigp_buffer = zalloc(fs->blksz); | |
| if (!tigp_buffer) { | |
| printf("No memory\n"); | |
| return; | |
| } | |
| tib_start_addr = tigp_buffer; | |
| blknr = le32_to_cpu(inode->b.blocks.triple_indir_block); | |
| status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, | |
| fs->blksz, (char *)tigp_buffer); | |
| for (i = 0; i < fs->blksz / sizeof(int); i++) { | |
| if (*tigp_buffer == 0) | |
| break; | |
| debug("tigp buffer releasing %u\n", *tigp_buffer); | |
| tip_buffer = zalloc(fs->blksz); | |
| if (!tip_buffer) | |
| goto fail; | |
| tipb_start_addr = tip_buffer; | |
| status = ext4fs_devread((lbaint_t)le32_to_cpu(*tigp_buffer) * | |
| fs->sect_perblk, 0, fs->blksz, | |
| (char *)tip_buffer); | |
| for (j = 0; j < fs->blksz / sizeof(int); j++) { | |
| if (le32_to_cpu(*tip_buffer) == 0) | |
| break; | |
| bg_idx = le32_to_cpu(*tip_buffer) / blk_per_grp; | |
| if (fs->blksz == 1024) { | |
| remainder = le32_to_cpu(*tip_buffer) % blk_per_grp; | |
| if (!remainder) | |
| bg_idx--; | |
| } | |
| ext4fs_reset_block_bmap(le32_to_cpu(*tip_buffer), | |
| fs->blk_bmaps[bg_idx], | |
| bg_idx); | |
| tip_buffer++; | |
| /* get block group descriptor table */ | |
| bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
| ext4fs_bg_free_blocks_inc(bgd, fs); | |
| ext4fs_sb_free_blocks_inc(fs->sb); | |
| /* journal backup */ | |
| if (prev_bg_bmap_idx != bg_idx) { | |
| uint64_t b_bitmap_blk = | |
| ext4fs_bg_get_block_id(bgd, fs); | |
| status = | |
| ext4fs_devread( | |
| b_bitmap_blk * | |
| fs->sect_perblk, 0, | |
| fs->blksz, | |
| journal_buffer); | |
| if (status == 0) | |
| goto fail; | |
| if (ext4fs_log_journal(journal_buffer, | |
| b_bitmap_blk)) | |
| goto fail; | |
| prev_bg_bmap_idx = bg_idx; | |
| } | |
| } | |
| free(tipb_start_addr); | |
| tipb_start_addr = NULL; | |
| /* | |
| * removing the grand parent blocks | |
| * which is connected to inode | |
| */ | |
| bg_idx = le32_to_cpu(*tigp_buffer) / blk_per_grp; | |
| if (fs->blksz == 1024) { | |
| remainder = le32_to_cpu(*tigp_buffer) % blk_per_grp; | |
| if (!remainder) | |
| bg_idx--; | |
| } | |
| ext4fs_reset_block_bmap(le32_to_cpu(*tigp_buffer), | |
| fs->blk_bmaps[bg_idx], bg_idx); | |
| tigp_buffer++; | |
| /* get block group descriptor table */ | |
| bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
| ext4fs_bg_free_blocks_inc(bgd, fs); | |
| ext4fs_sb_free_blocks_inc(fs->sb); | |
| /* journal backup */ | |
| if (prev_bg_bmap_idx != bg_idx) { | |
| uint64_t b_bitmap_blk = | |
| ext4fs_bg_get_block_id(bgd, fs); | |
| memset(journal_buffer, '\0', fs->blksz); | |
| status = ext4fs_devread(b_bitmap_blk * | |
| fs->sect_perblk, 0, | |
| fs->blksz, | |
| journal_buffer); | |
| if (status == 0) | |
| goto fail; | |
| if (ext4fs_log_journal(journal_buffer, | |
| b_bitmap_blk)) | |
| goto fail; | |
| prev_bg_bmap_idx = bg_idx; | |
| } | |
| } | |
| /* removing the grand parent triple indirect block */ | |
| blknr = le32_to_cpu(inode->b.blocks.triple_indir_block); | |
| bg_idx = blknr / blk_per_grp; | |
| if (fs->blksz == 1024) { | |
| remainder = blknr % blk_per_grp; | |
| if (!remainder) | |
| bg_idx--; | |
| } | |
| ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); | |
| /* get block group descriptor table */ | |
| bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
| ext4fs_bg_free_blocks_inc(bgd, fs); | |
| ext4fs_sb_free_blocks_inc(fs->sb); | |
| /* journal backup */ | |
| if (prev_bg_bmap_idx != bg_idx) { | |
| uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); | |
| status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk, | |
| 0, fs->blksz, journal_buffer); | |
| if (status == 0) | |
| goto fail; | |
| if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) | |
| goto fail; | |
| prev_bg_bmap_idx = bg_idx; | |
| } | |
| debug("tigp buffer itself releasing %d\n", blknr); | |
| } | |
| fail: | |
| free(tib_start_addr); | |
| free(tipb_start_addr); | |
| free(journal_buffer); | |
| } | |
| static int ext4fs_delete_file(int inodeno) | |
| { | |
| struct ext2_inode inode; | |
| short status; | |
| int i; | |
| int remainder; | |
| long int blknr; | |
| int bg_idx; | |
| int ibmap_idx; | |
| char *read_buffer = NULL; | |
| char *start_block_address = NULL; | |
| uint32_t no_blocks; | |
| static int prev_bg_bmap_idx = -1; | |
| unsigned int inodes_per_block; | |
| uint32_t blkno; | |
| unsigned int blkoff; | |
| uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); | |
| uint32_t inode_per_grp = le32_to_cpu(ext4fs_root->sblock.inodes_per_group); | |
| struct ext2_inode *inode_buffer = NULL; | |
| struct ext2_block_group *bgd = NULL; | |
| struct ext_filesystem *fs = get_fs(); | |
| char *journal_buffer = zalloc(fs->blksz); | |
| if (!journal_buffer) | |
| return -ENOMEM; | |
| status = ext4fs_read_inode(ext4fs_root, inodeno, &inode); | |
| if (status == 0) | |
| goto fail; | |
| /* read the block no allocated to a file */ | |
| no_blocks = le32_to_cpu(inode.size) / fs->blksz; | |
| if (le32_to_cpu(inode.size) % fs->blksz) | |
| no_blocks++; | |
| if (le32_to_cpu(inode.flags) & EXT4_EXTENTS_FL) { | |
| /* FIXME delete extent index blocks, i.e. eh_depth >= 1 */ | |
| struct ext4_extent_header *eh = | |
| (struct ext4_extent_header *) | |
| inode.b.blocks.dir_blocks; | |
| debug("del: dep=%d entries=%d\n", eh->eh_depth, eh->eh_entries); | |
| } else { | |
| delete_single_indirect_block(&inode); | |
| delete_double_indirect_block(&inode); | |
| delete_triple_indirect_block(&inode); | |
| } | |
| /* release data blocks */ | |
| for (i = 0; i < no_blocks; i++) { | |
| blknr = read_allocated_block(&inode, i); | |
| if (blknr == 0) | |
| continue; | |
| if (blknr < 0) | |
| goto fail; | |
| bg_idx = blknr / blk_per_grp; | |
| if (fs->blksz == 1024) { | |
| remainder = blknr % blk_per_grp; | |
| if (!remainder) | |
| bg_idx--; | |
| } | |
| ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], | |
| bg_idx); | |
| debug("EXT4 Block releasing %ld: %d\n", blknr, bg_idx); | |
| /* get block group descriptor table */ | |
| bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
| ext4fs_bg_free_blocks_inc(bgd, fs); | |
| ext4fs_sb_free_blocks_inc(fs->sb); | |
| /* journal backup */ | |
| if (prev_bg_bmap_idx != bg_idx) { | |
| uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); | |
| status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk, | |
| 0, fs->blksz, | |
| journal_buffer); | |
| if (status == 0) | |
| goto fail; | |
| if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) | |
| goto fail; | |
| prev_bg_bmap_idx = bg_idx; | |
| } | |
| } | |
| /* release inode */ | |
| /* from the inode no to blockno */ | |
| inodes_per_block = fs->blksz / fs->inodesz; | |
| ibmap_idx = inodeno / inode_per_grp; | |
| /* get the block no */ | |
| inodeno--; | |
| /* get block group descriptor table */ | |
| bgd = ext4fs_get_group_descriptor(fs, ibmap_idx); | |
| blkno = ext4fs_bg_get_inode_table_id(bgd, fs) + | |
| (inodeno % inode_per_grp) / inodes_per_block; | |
| /* get the offset of the inode */ | |
| blkoff = ((inodeno) % inodes_per_block) * fs->inodesz; | |
| /* read the block no containing the inode */ | |
| read_buffer = zalloc(fs->blksz); | |
| if (!read_buffer) | |
| goto fail; | |
| start_block_address = read_buffer; | |
| status = ext4fs_devread((lbaint_t)blkno * fs->sect_perblk, | |
| 0, fs->blksz, read_buffer); | |
| if (status == 0) | |
| goto fail; | |
| if (ext4fs_log_journal(read_buffer, blkno)) | |
| goto fail; | |
| read_buffer = read_buffer + blkoff; | |
| inode_buffer = (struct ext2_inode *)read_buffer; | |
| memset(inode_buffer, '\0', fs->inodesz); | |
| /* write the inode to original position in inode table */ | |
| if (ext4fs_put_metadata(start_block_address, blkno)) | |
| goto fail; | |
| /* update the respective inode bitmaps */ | |
| inodeno++; | |
| ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx); | |
| ext4fs_bg_free_inodes_inc(bgd, fs); | |
| ext4fs_sb_free_inodes_inc(fs->sb); | |
| /* journal backup */ | |
| memset(journal_buffer, '\0', fs->blksz); | |
| status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) * | |
| fs->sect_perblk, 0, fs->blksz, journal_buffer); | |
| if (status == 0) | |
| goto fail; | |
| if (ext4fs_log_journal(journal_buffer, ext4fs_bg_get_inode_id(bgd, fs))) | |
| goto fail; | |
| ext4fs_update(); | |
| ext4fs_deinit(); | |
| ext4fs_reinit_global(); | |
| if (ext4fs_init() != 0) { | |
| printf("error in File System init\n"); | |
| goto fail; | |
| } | |
| free(start_block_address); | |
| free(journal_buffer); | |
| return 0; | |
| fail: | |
| free(start_block_address); | |
| free(journal_buffer); | |
| return -1; | |
| } | |
| int ext4fs_init(void) | |
| { | |
| short status; | |
| int i; | |
| uint32_t real_free_blocks = 0; | |
| struct ext_filesystem *fs = get_fs(); | |
| /* populate fs */ | |
| fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root); | |
| fs->sect_perblk = fs->blksz >> fs->dev_desc->log2blksz; | |
| /* get the superblock */ | |
| fs->sb = zalloc(SUPERBLOCK_SIZE); | |
| if (!fs->sb) | |
| return -ENOMEM; | |
| if (!ext4_read_superblock((char *)fs->sb)) | |
| goto fail; | |
| /* init journal */ | |
| if (ext4fs_init_journal()) | |
| goto fail; | |
| /* get total no of blockgroups */ | |
| fs->no_blkgrp = (uint32_t)ext4fs_div_roundup( | |
| le32_to_cpu(ext4fs_root->sblock.total_blocks) | |
| - le32_to_cpu(ext4fs_root->sblock.first_data_block), | |
| le32_to_cpu(ext4fs_root->sblock.blocks_per_group)); | |
| /* get the block group descriptor table */ | |
| fs->gdtable_blkno = ((EXT2_MIN_BLOCK_SIZE == fs->blksz) + 1); | |
| if (ext4fs_get_bgdtable() == -1) { | |
| printf("Error in getting the block group descriptor table\n"); | |
| goto fail; | |
| } | |
| /* load all the available bitmap block of the partition */ | |
| fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *)); | |
| if (!fs->blk_bmaps) | |
| goto fail; | |
| for (i = 0; i < fs->no_blkgrp; i++) { | |
| fs->blk_bmaps[i] = zalloc(fs->blksz); | |
| if (!fs->blk_bmaps[i]) | |
| goto fail; | |
| } | |
| for (i = 0; i < fs->no_blkgrp; i++) { | |
| struct ext2_block_group *bgd = | |
| ext4fs_get_group_descriptor(fs, i); | |
| status = ext4fs_devread(ext4fs_bg_get_block_id(bgd, fs) * | |
| fs->sect_perblk, 0, | |
| fs->blksz, (char *)fs->blk_bmaps[i]); | |
| if (status == 0) | |
| goto fail; | |
| } | |
| /* load all the available inode bitmap of the partition */ | |
| fs->inode_bmaps = zalloc(fs->no_blkgrp * sizeof(unsigned char *)); | |
| if (!fs->inode_bmaps) | |
| goto fail; | |
| for (i = 0; i < fs->no_blkgrp; i++) { | |
| fs->inode_bmaps[i] = zalloc(fs->blksz); | |
| if (!fs->inode_bmaps[i]) | |
| goto fail; | |
| } | |
| for (i = 0; i < fs->no_blkgrp; i++) { | |
| struct ext2_block_group *bgd = | |
| ext4fs_get_group_descriptor(fs, i); | |
| status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) * | |
| fs->sect_perblk, | |
| 0, fs->blksz, | |
| (char *)fs->inode_bmaps[i]); | |
| if (status == 0) | |
| goto fail; | |
| } | |
| /* | |
| * check filesystem consistency with free blocks of file system | |
| * some time we observed that superblock freeblocks does not match | |
| * with the blockgroups freeblocks when improper | |
| * reboot of a linux kernel | |
| */ | |
| for (i = 0; i < fs->no_blkgrp; i++) { | |
| struct ext2_block_group *bgd = | |
| ext4fs_get_group_descriptor(fs, i); | |
| real_free_blocks = real_free_blocks + | |
| ext4fs_bg_get_free_blocks(bgd, fs); | |
| } | |
| if (real_free_blocks != ext4fs_sb_get_free_blocks(fs->sb)) | |
| ext4fs_sb_set_free_blocks(fs->sb, real_free_blocks); | |
| return 0; | |
| fail: | |
| ext4fs_deinit(); | |
| return -1; | |
| } | |
| void ext4fs_deinit(void) | |
| { | |
| int i; | |
| struct ext2_inode inode_journal; | |
| struct journal_superblock_t *jsb; | |
| uint32_t blknr; | |
| struct ext_filesystem *fs = get_fs(); | |
| uint32_t new_feature_incompat; | |
| /* free journal */ | |
| char *temp_buff = zalloc(fs->blksz); | |
| if (temp_buff) { | |
| ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, | |
| &inode_journal); | |
| blknr = read_allocated_block(&inode_journal, | |
| EXT2_JOURNAL_SUPERBLOCK); | |
| ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz, | |
| temp_buff); | |
| jsb = (struct journal_superblock_t *)temp_buff; | |
| jsb->s_start = 0; | |
| put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), | |
| (struct journal_superblock_t *)temp_buff, fs->blksz); | |
| free(temp_buff); | |
| } | |
| ext4fs_free_journal(); | |
| /* get the superblock */ | |
| ext4_read_superblock((char *)fs->sb); | |
| new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat); | |
| new_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER; | |
| fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat); | |
| put_ext4((uint64_t)(SUPERBLOCK_SIZE), | |
| (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE); | |
| free(fs->sb); | |
| fs->sb = NULL; | |
| if (fs->blk_bmaps) { | |
| for (i = 0; i < fs->no_blkgrp; i++) { | |
| free(fs->blk_bmaps[i]); | |
| fs->blk_bmaps[i] = NULL; | |
| } | |
| free(fs->blk_bmaps); | |
| fs->blk_bmaps = NULL; | |
| } | |
| if (fs->inode_bmaps) { | |
| for (i = 0; i < fs->no_blkgrp; i++) { | |
| free(fs->inode_bmaps[i]); | |
| fs->inode_bmaps[i] = NULL; | |
| } | |
| free(fs->inode_bmaps); | |
| fs->inode_bmaps = NULL; | |
| } | |
| free(fs->gdtable); | |
| fs->gdtable = NULL; | |
| /* | |
| * reinitiliazed the global inode and | |
| * block bitmap first execution check variables | |
| */ | |
| fs->first_pass_ibmap = 0; | |
| fs->first_pass_bbmap = 0; | |
| fs->curr_inode_no = 0; | |
| fs->curr_blkno = 0; | |
| } | |
| /* | |
| * Write data to filesystem blocks. Uses same optimization for | |
| * contigous sectors as ext4fs_read_file | |
| */ | |
| static int ext4fs_write_file(struct ext2_inode *file_inode, | |
| int pos, unsigned int len, char *buf) | |
| { | |
| int i; | |
| int blockcnt; | |
| uint32_t filesize = le32_to_cpu(file_inode->size); | |
| struct ext_filesystem *fs = get_fs(); | |
| int log2blksz = fs->dev_desc->log2blksz; | |
| int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz; | |
| int previous_block_number = -1; | |
| int delayed_start = 0; | |
| int delayed_extent = 0; | |
| int delayed_next = 0; | |
| char *delayed_buf = NULL; | |
| /* Adjust len so it we can't read past the end of the file. */ | |
| if (len > filesize) | |
| len = filesize; | |
| blockcnt = ((len + pos) + fs->blksz - 1) / fs->blksz; | |
| for (i = pos / fs->blksz; i < blockcnt; i++) { | |
| long int blknr; | |
| int blockend = fs->blksz; | |
| int skipfirst = 0; | |
| blknr = read_allocated_block(file_inode, i); | |
| if (blknr <= 0) | |
| return -1; | |
| blknr = blknr << log2_fs_blocksize; | |
| if (blknr) { | |
| if (previous_block_number != -1) { | |
| if (delayed_next == blknr) { | |
| delayed_extent += blockend; | |
| delayed_next += blockend >> log2blksz; | |
| } else { /* spill */ | |
| put_ext4((uint64_t) | |
| ((uint64_t)delayed_start << log2blksz), | |
| delayed_buf, | |
| (uint32_t) delayed_extent); | |
| previous_block_number = blknr; | |
| delayed_start = blknr; | |
| delayed_extent = blockend; | |
| delayed_buf = buf; | |
| delayed_next = blknr + | |
| (blockend >> log2blksz); | |
| } | |
| } else { | |
| previous_block_number = blknr; | |
| delayed_start = blknr; | |
| delayed_extent = blockend; | |
| delayed_buf = buf; | |
| delayed_next = blknr + | |
| (blockend >> log2blksz); | |
| } | |
| } else { | |
| if (previous_block_number != -1) { | |
| /* spill */ | |
| put_ext4((uint64_t) ((uint64_t)delayed_start << | |
| log2blksz), | |
| delayed_buf, | |
| (uint32_t) delayed_extent); | |
| previous_block_number = -1; | |
| } | |
| memset(buf, 0, fs->blksz - skipfirst); | |
| } | |
| buf += fs->blksz - skipfirst; | |
| } | |
| if (previous_block_number != -1) { | |
| /* spill */ | |
| put_ext4((uint64_t) ((uint64_t)delayed_start << log2blksz), | |
| delayed_buf, (uint32_t) delayed_extent); | |
| previous_block_number = -1; | |
| } | |
| return len; | |
| } | |
| int ext4fs_write(const char *fname, unsigned char *buffer, | |
| unsigned long sizebytes) | |
| { | |
| int ret = 0; | |
| struct ext2_inode *file_inode = NULL; | |
| unsigned char *inode_buffer = NULL; | |
| int parent_inodeno; | |
| int inodeno; | |
| time_t timestamp = 0; | |
| uint64_t bytes_reqd_for_file; | |
| unsigned int blks_reqd_for_file; | |
| unsigned int blocks_remaining; | |
| int existing_file_inodeno; | |
| char *temp_ptr = NULL; | |
| long int itable_blkno; | |
| long int parent_itable_blkno; | |
| long int blkoff; | |
| struct ext2_sblock *sblock = &(ext4fs_root->sblock); | |
| unsigned int inodes_per_block; | |
| unsigned int ibmap_idx; | |
| struct ext2_block_group *bgd = NULL; | |
| struct ext_filesystem *fs = get_fs(); | |
| ALLOC_CACHE_ALIGN_BUFFER(char, filename, 256); | |
| memset(filename, 0x00, 256); | |
| g_parent_inode = zalloc(fs->inodesz); | |
| if (!g_parent_inode) | |
| goto fail; | |
| if (ext4fs_init() != 0) { | |
| printf("error in File System init\n"); | |
| return -1; | |
| } | |
| inodes_per_block = fs->blksz / fs->inodesz; | |
| parent_inodeno = ext4fs_get_parent_inode_num(fname, filename, F_FILE); | |
| if (parent_inodeno == -1) | |
| goto fail; | |
| if (ext4fs_iget(parent_inodeno, g_parent_inode)) | |
| goto fail; | |
| /* do not mess up a directory using hash trees */ | |
| if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) { | |
| printf("hash tree directory\n"); | |
| goto fail; | |
| } | |
| /* check if the filename is already present in root */ | |
| existing_file_inodeno = ext4fs_filename_unlink(filename); | |
| if (existing_file_inodeno != -1) { | |
| ret = ext4fs_delete_file(existing_file_inodeno); | |
| fs->first_pass_bbmap = 0; | |
| fs->curr_blkno = 0; | |
| fs->first_pass_ibmap = 0; | |
| fs->curr_inode_no = 0; | |
| if (ret) | |
| goto fail; | |
| } | |
| /* calucalate how many blocks required */ | |
| bytes_reqd_for_file = sizebytes; | |
| blks_reqd_for_file = lldiv(bytes_reqd_for_file, fs->blksz); | |
| if (do_div(bytes_reqd_for_file, fs->blksz) != 0) { | |
| blks_reqd_for_file++; | |
| debug("total bytes for a file %u\n", blks_reqd_for_file); | |
| } | |
| blocks_remaining = blks_reqd_for_file; | |
| /* test for available space in partition */ | |
| if (le32_to_cpu(fs->sb->free_blocks) < blks_reqd_for_file) { | |
| printf("Not enough space on partition !!!\n"); | |
| goto fail; | |
| } | |
| inodeno = ext4fs_update_parent_dentry(filename, FILETYPE_REG); | |
| if (inodeno == -1) | |
| goto fail; | |
| /* prepare file inode */ | |
| inode_buffer = zalloc(fs->inodesz); | |
| if (!inode_buffer) | |
| goto fail; | |
| file_inode = (struct ext2_inode *)inode_buffer; | |
| file_inode->mode = cpu_to_le16(S_IFREG | S_IRWXU | | |
| S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH); | |
| /* ToDo: Update correct time */ | |
| file_inode->mtime = cpu_to_le32(timestamp); | |
| file_inode->atime = cpu_to_le32(timestamp); | |
| file_inode->ctime = cpu_to_le32(timestamp); | |
| file_inode->nlinks = cpu_to_le16(1); | |
| file_inode->size = cpu_to_le32(sizebytes); | |
| /* Allocate data blocks */ | |
| ext4fs_allocate_blocks(file_inode, blocks_remaining, | |
| &blks_reqd_for_file); | |
| file_inode->blockcnt = cpu_to_le32((blks_reqd_for_file * fs->blksz) >> | |
| fs->dev_desc->log2blksz); | |
| temp_ptr = zalloc(fs->blksz); | |
| if (!temp_ptr) | |
| goto fail; | |
| ibmap_idx = inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group); | |
| inodeno--; | |
| bgd = ext4fs_get_group_descriptor(fs, ibmap_idx); | |
| itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) + | |
| (inodeno % le32_to_cpu(sblock->inodes_per_group)) / | |
| inodes_per_block; | |
| blkoff = (inodeno % inodes_per_block) * fs->inodesz; | |
| ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz, | |
| temp_ptr); | |
| if (ext4fs_log_journal(temp_ptr, itable_blkno)) | |
| goto fail; | |
| memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz); | |
| if (ext4fs_put_metadata(temp_ptr, itable_blkno)) | |
| goto fail; | |
| /* copy the file content into data blocks */ | |
| if (ext4fs_write_file(file_inode, 0, sizebytes, (char *)buffer) == -1) { | |
| printf("Error in copying content\n"); | |
| /* FIXME: Deallocate data blocks */ | |
| goto fail; | |
| } | |
| ibmap_idx = parent_inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group); | |
| parent_inodeno--; | |
| bgd = ext4fs_get_group_descriptor(fs, ibmap_idx); | |
| parent_itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) + | |
| (parent_inodeno % | |
| le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block; | |
| blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz; | |
| if (parent_itable_blkno != itable_blkno) { | |
| memset(temp_ptr, '\0', fs->blksz); | |
| ext4fs_devread((lbaint_t)parent_itable_blkno * fs->sect_perblk, | |
| 0, fs->blksz, temp_ptr); | |
| if (ext4fs_log_journal(temp_ptr, parent_itable_blkno)) | |
| goto fail; | |
| memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz); | |
| if (ext4fs_put_metadata(temp_ptr, parent_itable_blkno)) | |
| goto fail; | |
| } else { | |
| /* | |
| * If parent and child fall in same inode table block | |
| * both should be kept in 1 buffer | |
| */ | |
| memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz); | |
| gd_index--; | |
| if (ext4fs_put_metadata(temp_ptr, itable_blkno)) | |
| goto fail; | |
| } | |
| ext4fs_update(); | |
| ext4fs_deinit(); | |
| fs->first_pass_bbmap = 0; | |
| fs->curr_blkno = 0; | |
| fs->first_pass_ibmap = 0; | |
| fs->curr_inode_no = 0; | |
| free(inode_buffer); | |
| free(g_parent_inode); | |
| free(temp_ptr); | |
| g_parent_inode = NULL; | |
| return 0; | |
| fail: | |
| ext4fs_deinit(); | |
| free(inode_buffer); | |
| free(g_parent_inode); | |
| free(temp_ptr); | |
| g_parent_inode = NULL; | |
| return -1; | |
| } | |
| int ext4_write_file(const char *filename, void *buf, loff_t offset, | |
| loff_t len, loff_t *actwrite) | |
| { | |
| int ret; | |
| if (offset != 0) { | |
| printf("** Cannot support non-zero offset **\n"); | |
| return -1; | |
| } | |
| ret = ext4fs_write(filename, buf, len); | |
| if (ret) { | |
| printf("** Error ext4fs_write() **\n"); | |
| goto fail; | |
| } | |
| *actwrite = len; | |
| return 0; | |
| fail: | |
| *actwrite = 0; | |
| return -1; | |
| } |