Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ext4: fix endianess problems in ext4 write support

Browse Source 
All fields were accessed directly instead of using the proper byte swap
functions. Thus, ext4 write support was only usable on little-endian
architectures. Fix this.

Signed-off-by: Michael Walle <michael@walle.cc>
master
Michael Walle 9 years ago committed by Tom Rini
parent 7f101be314
commit 58a9ecbaf4
6 changed files with 311 additions and 250 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 282
      fs/ext4/ext4_common.c
  2. 4
      fs/ext4/ext4_common.h
  3. 15
      fs/ext4/ext4_journal.c
  4. 4
      fs/ext4/ext4_journal.h
  5. 254
      fs/ext4/ext4_write.c
  6. 2
      include/ext_common.h

282
fs/ext4/ext4_common.c
Unescape View File

@ -33,20 +33,45 @@
struct ext2_data *ext4fs_root;
struct ext2fs_node *ext4fs_file;
uint32_t *ext4fs_indir1_block;
__le32 *ext4fs_indir1_block;
int ext4fs_indir1_size;
int ext4fs_indir1_blkno = -1;
uint32_t *ext4fs_indir2_block;
__le32 *ext4fs_indir2_block;
int ext4fs_indir2_size;
int ext4fs_indir2_blkno = -1;
uint32_t *ext4fs_indir3_block;
__le32 *ext4fs_indir3_block;
int ext4fs_indir3_size;
int ext4fs_indir3_blkno = -1;
struct ext2_inode *g_parent_inode;
static int symlinknest;
#if defined(CONFIG_EXT4_WRITE)
static inline void ext4fs_sb_free_inodes_dec(struct ext2_sblock *sb)
{
sb->free_inodes = cpu_to_le32(le32_to_cpu(sb->free_inodes) - 1);
}
static inline void ext4fs_sb_free_blocks_dec(struct ext2_sblock *sb)
{
sb->free_blocks = cpu_to_le32(le32_to_cpu(sb->free_blocks) - 1);
}
static inline void ext4fs_bg_free_inodes_dec(struct ext2_block_group *bg)
{
bg->free_inodes = cpu_to_le16(le16_to_cpu(bg->free_inodes) - 1);
}
static inline void ext4fs_bg_free_blocks_dec(struct ext2_block_group *bg)
{
bg->free_blocks = cpu_to_le16(le16_to_cpu(bg->free_blocks) - 1);
}
static inline void ext4fs_bg_itable_unused_dec(struct ext2_block_group *bg)
{
bg->bg_itable_unused = cpu_to_le16(le16_to_cpu(bg->bg_itable_unused) - 1);
}
uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n)
{
uint32_t res = size / n;
@ -112,7 +137,7 @@ static int _get_new_inode_no(unsigned char *buffer)
while (*ptr == 255) {
ptr++;
count += 8;
if (count > ext4fs_root->sblock.inodes_per_group)
if (count > le32_to_cpu(ext4fs_root->sblock.inodes_per_group))
return -1;
}
@ -249,7 +274,7 @@ int ext4fs_set_inode_bmap(int inode_no, unsigned char *buffer, int index)
unsigned char *ptr = buffer;
unsigned char operand;
inode_no -= (index * ext4fs_root->sblock.inodes_per_group);
inode_no -= (index * le32_to_cpu(ext4fs_root->sblock.inodes_per_group));
i = inode_no / 8;
remainder = inode_no % 8;
if (remainder == 0) {
@ -274,7 +299,7 @@ void ext4fs_reset_inode_bmap(int inode_no, unsigned char *buffer, int index)
unsigned char *ptr = buffer;
unsigned char operand;
inode_no -= (index * ext4fs_root->sblock.inodes_per_group);
inode_no -= (index * le32_to_cpu(ext4fs_root->sblock.inodes_per_group));
i = inode_no / 8;
remainder = inode_no % 8;
if (remainder == 0) {
@ -289,19 +314,20 @@ void ext4fs_reset_inode_bmap(int inode_no, unsigned char *buffer, int index)
*ptr = *ptr & ~(operand);
}
int ext4fs_checksum_update(unsigned int i)
uint16_t ext4fs_checksum_update(uint32_t i)
{
struct ext2_block_group *desc;
struct ext_filesystem *fs = get_fs();
__u16 crc = 0;
uint16_t crc = 0;
__le32 le32_i = cpu_to_le32(i);
desc = (struct ext2_block_group *)&fs->bgd[i];
if (fs->sb->feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) {
if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) {
int offset = offsetof(struct ext2_block_group, bg_checksum);
crc = ext2fs_crc16(~0, fs->sb->unique_id,
sizeof(fs->sb->unique_id));
crc = ext2fs_crc16(crc, &i, sizeof(i));
crc = ext2fs_crc16(crc, &le32_i, sizeof(le32_i));
crc = ext2fs_crc16(crc, desc, offset);
offset += sizeof(desc->bg_checksum); /* skip checksum */
assert(offset == sizeof(*desc));
@ -322,7 +348,7 @@ static int check_void_in_dentry(struct ext2_dirent *dir, char *filename)
dentry_length = sizeof(struct ext2_dirent) +
dir->namelen + padding_factor;
sizeof_void_space = dir->direntlen - dentry_length;
sizeof_void_space = le16_to_cpu(dir->direntlen) - dentry_length;
if (sizeof_void_space == 0)
return 0;
@ -333,7 +359,7 @@ static int check_void_in_dentry(struct ext2_dirent *dir, char *filename)
new_entry_byte_reqd = strlen(filename) +
sizeof(struct ext2_dirent) + padding_factor;
if (sizeof_void_space >= new_entry_byte_reqd) {
dir->direntlen = dentry_length;
dir->direntlen = cpu_to_le16(dentry_length);
return sizeof_void_space;
}
@ -360,6 +386,9 @@ void ext4fs_update_parent_dentry(char *filename, int *p_ino, int file_type)
/* directory entry */
struct ext2_dirent *dir;
char *temp_dir = NULL;
uint32_t new_blk_no;
uint32_t new_size;
uint32_t new_blockcnt;
zero_buffer = zalloc(fs->blksz);
if (!zero_buffer) {
@ -396,7 +425,7 @@ restart:
goto fail;
dir = (struct ext2_dirent *)root_first_block_buffer;
totalbytes = 0;
while (dir->direntlen > 0) {
while (le16_to_cpu(dir->direntlen) > 0) {
/*
* blocksize-totalbytes because last directory length
* i.e. dir->direntlen is free availble space in the
@ -405,7 +434,7 @@ restart:
*/
/* traversing the each directory entry */
if (fs->blksz - totalbytes == dir->direntlen) {
if (fs->blksz - totalbytes == le16_to_cpu(dir->direntlen)) {
if (strlen(filename) % 4 != 0)
padding_factor = 4 - (strlen(filename) % 4);
@ -430,32 +459,34 @@ restart:
printf("Directory exceeds limit\n");
goto fail;
}
g_parent_inode->b.blocks.dir_blocks
[direct_blk_idx] = ext4fs_get_new_blk_no();
if (g_parent_inode->b.blocks.dir_blocks
[direct_blk_idx] == -1) {
new_blk_no = ext4fs_get_new_blk_no();
if (new_blk_no == -1) {
printf("no block left to assign\n");
goto fail;
}
put_ext4(((uint64_t)
((uint64_t)g_parent_inode->b.
blocks.dir_blocks[direct_blk_idx] *
(uint64_t)fs->blksz)), zero_buffer, fs->blksz);
g_parent_inode->size =
g_parent_inode->size + fs->blksz;
g_parent_inode->blockcnt =
g_parent_inode->blockcnt + fs->sect_perblk;
put_ext4((uint64_t)new_blk_no * fs->blksz, zero_buffer, fs->blksz);
g_parent_inode->b.blocks.dir_blocks[direct_blk_idx] =
cpu_to_le32(new_blk_no);
new_size = le32_to_cpu(g_parent_inode->size);
new_size += fs->blksz;
g_parent_inode->size = cpu_to_le32(new_size);
new_blockcnt = le32_to_cpu(g_parent_inode->blockcnt);
new_blockcnt += fs->sect_perblk;
g_parent_inode->blockcnt = cpu_to_le32(new_blockcnt);
if (ext4fs_put_metadata
(root_first_block_buffer,
first_block_no_of_root))
goto fail;
goto restart;
}
dir->direntlen = last_entry_dirlen;
dir->direntlen = cpu_to_le16(last_entry_dirlen);
break;
}
templength = dir->direntlen;
templength = le16_to_cpu(dir->direntlen);
totalbytes = totalbytes + templength;
sizeof_void_space = check_void_in_dentry(dir, filename);
if (sizeof_void_space)
@ -465,7 +496,7 @@ restart:
}
/* make a pointer ready for creating next directory entry */
templength = dir->direntlen;
templength = le16_to_cpu(dir->direntlen);
totalbytes = totalbytes + templength;
dir = (struct ext2_dirent *)((char *)dir + templength);
@ -475,11 +506,11 @@ restart:
printf("no inode left to assign\n");
goto fail;
}
dir->inode = inodeno;
dir->inode = cpu_to_le32(inodeno);
if (sizeof_void_space)
dir->direntlen = sizeof_void_space;
dir->direntlen = cpu_to_le16(sizeof_void_space);
else
dir->direntlen = fs->blksz - totalbytes;
dir->direntlen = cpu_to_le16(fs->blksz - totalbytes);
dir->namelen = strlen(filename);
dir->filetype = FILETYPE_REG; /* regular file */
@ -534,7 +565,7 @@ static int search_dir(struct ext2_inode *parent_inode, char *dirname)
dir = (struct ext2_dirent *)block_buffer;
ptr = (char *)dir;
totalbytes = 0;
while (dir->direntlen >= 0) {
while (le16_to_cpu(dir->direntlen) >= 0) {
/*
* blocksize-totalbytes because last directory
* length i.e.,*dir->direntlen is free availble
@ -542,23 +573,23 @@ static int search_dir(struct ext2_inode *parent_inode, char *dirname)
* it is a last entry of directory entry
*/
if (strlen(dirname) == dir->namelen) {
if (strncmp(dirname, ptr +
sizeof(struct ext2_dirent),
dir->namelen) == 0) {
previous_dir->direntlen +=
dir->direntlen;
inodeno = dir->inode;
if (strncmp(dirname, ptr + sizeof(struct ext2_dirent), dir->namelen) == 0) {
uint16_t new_len;
new_len = le16_to_cpu(previous_dir->direntlen);
new_len += le16_to_cpu(dir->direntlen);
previous_dir->direntlen = cpu_to_le16(new_len);
inodeno = le32_to_cpu(dir->inode);
dir->inode = 0;
found = 1;
break;
}
}
if (fs->blksz - totalbytes == dir->direntlen)
if (fs->blksz - totalbytes == le16_to_cpu(dir->direntlen))
break;
/* traversing the each directory entry */
templength = dir->direntlen;
templength = le16_to_cpu(dir->direntlen);
totalbytes = totalbytes + templength;
previous_dir = dir;
dir = (struct ext2_dirent *)((char *)dir + templength);
@ -720,7 +751,7 @@ end:
if (matched_inode_no != -1) {
ext4fs_iget(matched_inode_no, &temp_inode);
if (temp_inode.mode & S_IFDIR) {
if (le16_to_cpu(temp_inode.mode) & S_IFDIR) {
printf("It is a Directory\n");
result_inode_no = -1;
goto fail;
@ -780,7 +811,7 @@ static int check_filename(char *filename, unsigned int blknr)
dir = (struct ext2_dirent *)root_first_block_buffer;
ptr = (char *)dir;
totalbytes = 0;
while (dir->direntlen >= 0) {
while (le16_to_cpu(dir->direntlen) >= 0) {
/*
* blocksize-totalbytes because last
* directory length i.e., *dir->direntlen
@ -790,20 +821,23 @@ static int check_filename(char *filename, unsigned int blknr)
if (strlen(filename) == dir->namelen) {
if (strncmp(filename, ptr + sizeof(struct ext2_dirent),
dir->namelen) == 0) {
uint16_t new_len;
printf("file found deleting\n");
previous_dir->direntlen += dir->direntlen;
inodeno = dir->inode;
new_len = le16_to_cpu(previous_dir->direntlen);
new_len += le16_to_cpu(dir->direntlen);
previous_dir->direntlen = cpu_to_le16(new_len);
inodeno = le32_to_cpu(dir->inode);
dir->inode = 0;
found = 1;
break;
}
}
if (fs->blksz - totalbytes == dir->direntlen)
if (fs->blksz - totalbytes == le16_to_cpu(dir->direntlen))
break;
/* traversing the each directory entry */
templength = dir->direntlen;
templength = le16_to_cpu(dir->direntlen);
totalbytes = totalbytes + templength;
previous_dir = dir;
dir = (struct ext2_dirent *)((char *)dir + templength);
@ -843,14 +877,14 @@ int ext4fs_filename_check(char *filename)
return -1;
}
long int ext4fs_get_new_blk_no(void)
uint32_t ext4fs_get_new_blk_no(void)
{
short i;
short status;
int remainder;
unsigned int bg_idx;
static int prev_bg_bitmap_index = -1;
unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
unsigned int blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
struct ext_filesystem *fs = get_fs();
char *journal_buffer = zalloc(fs->blksz);
char *zero_buffer = zalloc(fs->blksz);
@ -860,14 +894,13 @@ long int ext4fs_get_new_blk_no(void)
if (fs->first_pass_bbmap == 0) {
for (i = 0; i < fs->no_blkgrp; i++) {
if (bgd[i].free_blocks) {
if (bgd[i].bg_flags & EXT4_BG_BLOCK_UNINIT) {
put_ext4(((uint64_t) ((uint64_t)bgd[i].block_id *
(uint64_t)fs->blksz)),
if (le16_to_cpu(bgd[i].free_blocks)) {
if (le16_to_cpu(bgd[i].bg_flags) & EXT4_BG_BLOCK_UNINIT) {
uint16_t new_flags;
put_ext4((uint64_t)le32_to_cpu(bgd[i].block_id) * fs->blksz,
zero_buffer, fs->blksz);
bgd[i].bg_flags =
bgd[i].
bg_flags & ~EXT4_BG_BLOCK_UNINIT;
new_flags = le16_to_cpu(bgd[i].bg_flags) & ~EXT4_BG_BLOCK_UNINIT;
bgd[i].bg_flags = cpu_to_le16(new_flags);
memcpy(fs->blk_bmaps[i], zero_buffer,
fs->blksz);
}
@ -879,17 +912,17 @@ long int ext4fs_get_new_blk_no(void)
fs->curr_blkno = fs->curr_blkno +
(i * fs->blksz * 8);
fs->first_pass_bbmap++;
bgd[i].free_blocks--;
fs->sb->free_blocks--;
status = ext4fs_devread((lbaint_t)
bgd[i].block_id *
ext4fs_bg_free_blocks_dec(&bgd[i]);
ext4fs_sb_free_blocks_dec(fs->sb);
status = ext4fs_devread(
(lbaint_t)le32_to_cpu(bgd[i].block_id) *
fs->sect_perblk, 0,
fs->blksz,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[i].block_id))
le32_to_cpu(bgd[i].block_id)))
goto fail;
goto success;
} else {
@ -923,13 +956,14 @@ restart:
goto restart;
}
if (bgd[bg_idx].bg_flags & EXT4_BG_BLOCK_UNINIT) {
if (le16_to_cpu(bgd[bg_idx].bg_flags) & EXT4_BG_BLOCK_UNINIT) {
uint16_t new_flags;
memset(zero_buffer, '\0', fs->blksz);
put_ext4(((uint64_t) ((uint64_t)bgd[bg_idx].block_id *
(uint64_t)fs->blksz)), zero_buffer, fs->blksz);
put_ext4((uint64_t)le32_to_cpu(bgd[bg_idx].block_id) * fs->blksz,
zero_buffer, fs->blksz);
memcpy(fs->blk_bmaps[bg_idx], zero_buffer, fs->blksz);
bgd[bg_idx].bg_flags = bgd[bg_idx].bg_flags &
~EXT4_BG_BLOCK_UNINIT;
new_flags = le16_to_cpu(bgd[bg_idx].bg_flags) & ~EXT4_BG_BLOCK_UNINIT;
bgd[bg_idx].bg_flags = cpu_to_le16(new_flags);
}
if (ext4fs_set_block_bmap(fs->curr_blkno, fs->blk_bmaps[bg_idx],
@ -942,19 +976,20 @@ restart:
/* journal backup */
if (prev_bg_bitmap_index != bg_idx) {
memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread((lbaint_t)bgd[bg_idx].block_id
status = ext4fs_devread(
(lbaint_t)le32_to_cpu(bgd[bg_idx].block_id)
* fs->sect_perblk,
0, fs->blksz, journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[bg_idx].block_id))
le32_to_cpu(bgd[bg_idx].block_id)))
goto fail;
prev_bg_bitmap_index = bg_idx;
}
bgd[bg_idx].free_blocks--;
fs->sb->free_blocks--;
ext4fs_bg_free_blocks_dec(&bgd[bg_idx]);
ext4fs_sb_free_blocks_dec(fs->sb);
goto success;
}
success:
@ -975,7 +1010,7 @@ int ext4fs_get_new_inode_no(void)
short status;
unsigned int ibmap_idx;
static int prev_inode_bitmap_index = -1;
unsigned int inodes_per_grp = ext4fs_root->sblock.inodes_per_group;
unsigned int inodes_per_grp = le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
struct ext_filesystem *fs = get_fs();
char *journal_buffer = zalloc(fs->blksz);
char *zero_buffer = zalloc(fs->blksz);
@ -990,13 +1025,12 @@ int ext4fs_get_new_inode_no(void)
bgd[i].free_inodes)
bgd[i].bg_itable_unused =
bgd[i].free_inodes;
if (bgd[i].bg_flags & EXT4_BG_INODE_UNINIT) {
put_ext4(((uint64_t)
((uint64_t)bgd[i].inode_id *
(uint64_t)fs->blksz)),
if (le16_to_cpu(bgd[i].bg_flags) & EXT4_BG_INODE_UNINIT) {
int new_flags;
put_ext4((uint64_t)le32_to_cpu(bgd[i].inode_id) * fs->blksz,
zero_buffer, fs->blksz);
bgd[i].bg_flags = bgd[i].bg_flags &
~EXT4_BG_INODE_UNINIT;
new_flags = le16_to_cpu(bgd[i].bg_flags) & ~EXT4_BG_INODE_UNINIT;
bgd[i].bg_flags = cpu_to_le16(new_flags);
memcpy(fs->inode_bmaps[i],
zero_buffer, fs->blksz);
}
@ -1008,18 +1042,18 @@ int ext4fs_get_new_inode_no(void)
fs->curr_inode_no = fs->curr_inode_no +
(i * inodes_per_grp);
fs->first_pass_ibmap++;
bgd[i].free_inodes--;
bgd[i].bg_itable_unused--;
fs->sb->free_inodes--;
status = ext4fs_devread((lbaint_t)
bgd[i].inode_id *
ext4fs_bg_free_inodes_dec(&bgd[i]);
ext4fs_bg_itable_unused_dec(&bgd[i]);
ext4fs_sb_free_inodes_dec(fs->sb);
status = ext4fs_devread(
(lbaint_t)le32_to_cpu(bgd[i].inode_id) *
fs->sect_perblk, 0,
fs->blksz,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[i].inode_id))
le32_to_cpu(bgd[i].inode_id)))
goto fail;
goto success;
} else
@ -1031,13 +1065,13 @@ restart:
fs->curr_inode_no++;
/* get the blockbitmap index respective to blockno */
ibmap_idx = fs->curr_inode_no / inodes_per_grp;
if (bgd[ibmap_idx].bg_flags & EXT4_BG_INODE_UNINIT) {
if (le16_to_cpu(bgd[ibmap_idx].bg_flags) & EXT4_BG_INODE_UNINIT) {
int new_flags;
memset(zero_buffer, '\0', fs->blksz);
put_ext4(((uint64_t) ((uint64_t)bgd[ibmap_idx].inode_id *
(uint64_t)fs->blksz)), zero_buffer,
fs->blksz);
bgd[ibmap_idx].bg_flags =
bgd[ibmap_idx].bg_flags & ~EXT4_BG_INODE_UNINIT;
put_ext4((uint64_t)le32_to_cpu(bgd[ibmap_idx].inode_id) * fs->blksz,
zero_buffer, fs->blksz);
new_flags = le16_to_cpu(bgd[ibmap_idx].bg_flags) & ~EXT4_BG_INODE_UNINIT;
bgd[ibmap_idx].bg_flags = cpu_to_le16(new_flags);
memcpy(fs->inode_bmaps[ibmap_idx], zero_buffer,
fs->blksz);
}
@ -1053,14 +1087,14 @@ restart:
/* journal backup */
if (prev_inode_bitmap_index != ibmap_idx) {
memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread((lbaint_t)
bgd[ibmap_idx].inode_id
status = ext4fs_devread(
(lbaint_t)le32_to_cpu(bgd[ibmap_idx].inode_id)
* fs->sect_perblk,
0, fs->blksz, journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[ibmap_idx].inode_id))
le32_to_cpu(bgd[ibmap_idx].inode_id)))
goto fail;
prev_inode_bitmap_index = ibmap_idx;
}
@ -1068,9 +1102,9 @@ restart:
bgd[ibmap_idx].free_inodes)
bgd[ibmap_idx].bg_itable_unused =
bgd[ibmap_idx].free_inodes;
bgd[ibmap_idx].free_inodes--;
bgd[ibmap_idx].bg_itable_unused--;
fs->sb->free_inodes--;
ext4fs_bg_free_inodes_dec(&bgd[ibmap_idx]);
ext4fs_bg_itable_unused_dec(&bgd[ibmap_idx]);
ext4fs_sb_free_inodes_dec(fs->sb);
goto success;
}
@ -1097,8 +1131,8 @@ static void alloc_single_indirect_block(struct ext2_inode *file_inode,
long int actual_block_no;
long int si_blockno;
/* si :single indirect */
unsigned int *si_buffer = NULL;
unsigned int *si_start_addr = NULL;
__le32 *si_buffer = NULL;
__le32 *si_start_addr = NULL;
struct ext_filesystem *fs = get_fs();
if (*total_remaining_blocks != 0) {
@ -1128,7 +1162,7 @@ static void alloc_single_indirect_block(struct ext2_inode *file_inode,
printf("no block left to assign\n");
goto fail;
}
*si_buffer = actual_block_no;
*si_buffer = cpu_to_le32(actual_block_no);
debug("SIAB %u: %u\n", *si_buffer,
*total_remaining_blocks);
@ -1141,7 +1175,7 @@ static void alloc_single_indirect_block(struct ext2_inode *file_inode,
/* write the block to disk */
put_ext4(((uint64_t) ((uint64_t)si_blockno * (uint64_t)fs->blksz)),
si_start_addr, fs->blksz);
file_inode->b.blocks.indir_block = si_blockno;
file_inode->b.blocks.indir_block = cpu_to_le32(si_blockno);
}
fail:
free(si_start_addr);
@ -1158,10 +1192,10 @@ static void alloc_double_indirect_block(struct ext2_inode *file_inode,
/* di:double indirect */
long int di_blockno_parent;
long int di_blockno_child;
unsigned int *di_parent_buffer = NULL;
unsigned int *di_child_buff = NULL;
unsigned int *di_block_start_addr = NULL;
unsigned int *di_child_buff_start = NULL;
__le32 *di_parent_buffer = NULL;
__le32 *di_child_buff = NULL;
__le32 *di_block_start_addr = NULL;
__le32 *di_child_buff_start = NULL;
struct ext_filesystem *fs = get_fs();
if (*total_remaining_blocks != 0) {
@ -1205,7 +1239,7 @@ static void alloc_double_indirect_block(struct ext2_inode *file_inode,
goto fail;
di_child_buff_start = di_child_buff;
*di_parent_buffer = di_blockno_child;
*di_parent_buffer = cpu_to_le32(di_blockno_child);
di_parent_buffer++;
(*no_blks_reqd)++;
debug("DICB %ld: %u\n", di_blockno_child,
@ -1228,7 +1262,7 @@ static void alloc_double_indirect_block(struct ext2_inode *file_inode,
printf("no block left to assign\n");
goto fail;
}
*di_child_buff = actual_block_no;
*di_child_buff = cpu_to_le32(actual_block_no);
debug("DIAB %ld: %u\n", actual_block_no,
*total_remaining_blocks);
@ -1248,7 +1282,7 @@ static void alloc_double_indirect_block(struct ext2_inode *file_inode,
}
put_ext4(((uint64_t) ((uint64_t)di_blockno_parent * (uint64_t)fs->blksz)),
di_block_start_addr, fs->blksz);
file_inode->b.blocks.double_indir_block = di_blockno_parent;
file_inode->b.blocks.double_indir_block = cpu_to_le32(di_blockno_parent);
}
fail:
free(di_block_start_addr);
@ -1266,12 +1300,12 @@ static void alloc_triple_indirect_block(struct ext2_inode *file_inode,
long int ti_gp_blockno;
long int ti_parent_blockno;
long int ti_child_blockno;
unsigned int *ti_gp_buff = NULL;
unsigned int *ti_parent_buff = NULL;
unsigned int *ti_child_buff = NULL;
unsigned int *ti_gp_buff_start_addr = NULL;
unsigned int *ti_pbuff_start_addr = NULL;
unsigned int *ti_cbuff_start_addr = NULL;
__le32 *ti_gp_buff = NULL;
__le32 *ti_parent_buff = NULL;
__le32 *ti_child_buff = NULL;
__le32 *ti_gp_buff_start_addr = NULL;
__le32 *ti_pbuff_start_addr = NULL;
__le32 *ti_cbuff_start_addr = NULL;
struct ext_filesystem *fs = get_fs();
if (*total_remaining_blocks != 0) {
/* triple indirect grand parent block connecting to inode */
@ -1301,7 +1335,7 @@ static void alloc_triple_indirect_block(struct ext2_inode *file_inode,
goto fail;
ti_pbuff_start_addr = ti_parent_buff;
*ti_gp_buff = ti_parent_blockno;
*ti_gp_buff = cpu_to_le32(ti_parent_blockno);
ti_gp_buff++;
(*no_blks_reqd)++;
debug("TIPB %ld: %u\n", ti_parent_blockno,
@ -1319,7 +1353,7 @@ static void alloc_triple_indirect_block(struct ext2_inode *file_inode,
goto fail1;
ti_cbuff_start_addr = ti_child_buff;
*ti_parent_buff = ti_child_blockno;
*ti_parent_buff = cpu_to_le32(ti_child_blockno);
ti_parent_buff++;
(*no_blks_reqd)++;
debug("TICB %ld: %u\n", ti_parent_blockno,
@ -1335,7 +1369,7 @@ static void alloc_triple_indirect_block(struct ext2_inode *file_inode,
free(ti_cbuff_start_addr);
goto fail1;
}
*ti_child_buff = actual_block_no;
*ti_child_buff = cpu_to_le32(actual_block_no);
debug("TIAB %ld: %u\n", actual_block_no,
*total_remaining_blocks);
@ -1364,7 +1398,7 @@ static void alloc_triple_indirect_block(struct ext2_inode *file_inode,
/* write the grand parent block */
put_ext4(((uint64_t) ((uint64_t)ti_gp_blockno * (uint64_t)fs->blksz)),
ti_gp_buff_start_addr, fs->blksz);
file_inode->b.blocks.triple_indir_block = ti_gp_blockno;
file_inode->b.blocks.triple_indir_block = cpu_to_le32(ti_gp_blockno);
free(ti_gp_buff_start_addr);
return;
}
@ -1389,7 +1423,7 @@ void ext4fs_allocate_blocks(struct ext2_inode *file_inode,
printf("no block left to assign\n");
return;
}
file_inode->b.blocks.dir_blocks[i] = direct_blockno;
file_inode->b.blocks.dir_blocks[i] = cpu_to_le32(direct_blockno);
debug("DB %ld: %u\n", direct_blockno, total_remaining_blocks);
total_remaining_blocks--;
@ -1420,7 +1454,7 @@ static struct ext4_extent_header *ext4fs_get_extent_block
index = (struct ext4_extent_idx *)(ext_block + 1);
if (le16_to_cpu(ext_block->eh_magic) != EXT4_EXT_MAGIC)
return 0;
return NULL;
if (ext_block->eh_depth == 0)
return ext_block;
@ -1432,7 +1466,7 @@ static struct ext4_extent_header *ext4fs_get_extent_block
} while (fileblock >= le32_to_cpu(index[i].ei_block));
if (--i < 0)
return 0;
return NULL;
block = le16_to_cpu(index[i].ei_leaf_hi);
block = (block << 32) + le32_to_cpu(index[i].ei_leaf_lo);
@ -1441,7 +1475,7 @@ static struct ext4_extent_header *ext4fs_get_extent_block
buf))
ext_block = (struct ext4_extent_header *)buf;
else
return 0;
return NULL;
}
}
@ -2034,11 +2068,11 @@ static char *ext4fs_read_symlink(struct ext2fs_node *node)
if (!diro->inode_read) {
status = ext4fs_read_inode(diro->data, diro->ino, &diro->inode);
if (status == 0)
return 0;
return NULL;
}
symlink = zalloc(le32_to_cpu(diro->inode.size) + 1);
if (!symlink)
return 0;
return NULL;
if (le32_to_cpu(diro->inode.size) < sizeof(diro->inode.b.symlink)) {
strncpy(symlink, diro->inode.b.symlink,
@ -2049,7 +2083,7 @@ static char *ext4fs_read_symlink(struct ext2fs_node *node)
symlink, &actread);
if ((status < 0) || (actread == 0)) {
free(symlink);
return 0;
return NULL;
}
}
symlink[le32_to_cpu(diro->inode.size)] = '\0';
@ -2234,7 +2268,7 @@ int ext4fs_mount(unsigned part_length)
* and we do not support metadata_csum (and cannot reliably find
* files when it is set. Refuse to mount.
*/
if (data->sblock.feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) {
if (le32_to_cpu(data->sblock.feature_incompat) & EXT4_FEATURE_INCOMPAT_64BIT) {
printf("Unsupported feature found (64bit, possibly metadata_csum), not mounting\n");
goto fail;
}

4
fs/ext4/ext4_common.h
Unescape View File

@ -59,10 +59,10 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name,
#if defined(CONFIG_EXT4_WRITE)
uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n);
int ext4fs_checksum_update(unsigned int i);
uint16_t ext4fs_checksum_update(unsigned int i);
int ext4fs_get_parent_inode_num(const char *dirname, char *dname, int flags);
void ext4fs_update_parent_dentry(char *filename, int *p_ino, int file_type);
long int ext4fs_get_new_blk_no(void);
uint32_t ext4fs_get_new_blk_no(void);
int ext4fs_get_new_inode_no(void);
void ext4fs_reset_block_bmap(long int blockno, unsigned char *buffer,
int index);

15
fs/ext4/ext4_journal.c
Unescape View File

@ -151,7 +151,7 @@ int ext4fs_log_gdt(char *gd_table)
* journal_buffer -- Buffer containing meta data
* blknr -- Block number on disk of the meta data buffer
*/
int ext4fs_log_journal(char *journal_buffer, long int blknr)
int ext4fs_log_journal(char *journal_buffer, uint32_t blknr)
{
struct ext_filesystem *fs = get_fs();
short i;
@ -183,7 +183,7 @@ int ext4fs_log_journal(char *journal_buffer, long int blknr)
* metadata_buffer -- Buffer containing meta data
* blknr -- Block number on disk of the meta data buffer
*/
int ext4fs_put_metadata(char *metadata_buffer, long int blknr)
int ext4fs_put_metadata(char *metadata_buffer, uint32_t blknr)
{
struct ext_filesystem *fs = get_fs();
if (!metadata_buffer) {
@ -215,7 +215,7 @@ void print_revoke_blks(char *revk_blk)
printf("total bytes %d\n", max);
while (offset < max) {
blocknr = be32_to_cpu(*((long int *)(revk_blk + offset)));
blocknr = be32_to_cpu(*((__be32 *)(revk_blk + offset)));
printf("revoke blknr is %ld\n", blocknr);
offset += 4;
}
@ -302,7 +302,7 @@ int check_blknr_for_revoke(long int blknr, int sequence_no)
max = be32_to_cpu(header->r_count);
while (offset < max) {
blocknr = be32_to_cpu(*((long int *)
blocknr = be32_to_cpu(*((__be32 *)
(revk_blk + offset)));
if (blocknr == blknr)
goto found;
@ -420,7 +420,7 @@ int ext4fs_check_journal_state(int recovery_flag)
temp_buff);
jsb = (struct journal_superblock_t *) temp_buff;
if (fs->sb->feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) {
if (le32_to_cpu(fs->sb->feature_incompat) & EXT3_FEATURE_INCOMPAT_RECOVER) {
if (recovery_flag == RECOVER)
printf("Recovery required\n");
} else {
@ -517,11 +517,14 @@ int ext4fs_check_journal_state(int recovery_flag)
end:
if (recovery_flag == RECOVER) {
uint32_t new_feature_incompat;
jsb->s_start = cpu_to_be32(1);
jsb->s_sequence = cpu_to_be32(be32_to_cpu(jsb->s_sequence) + 1);
/* get the superblock */
ext4_read_superblock((char *)fs->sb);
fs->sb->feature_incompat |= EXT3_FEATURE_INCOMPAT_RECOVER;
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);
/* Update the super block */
put_ext4((uint64_t) (SUPERBLOCK_SIZE),

4
fs/ext4/ext4_journal.h
Unescape View File

@ -115,8 +115,8 @@ extern struct ext2_data *ext4fs_root;
int ext4fs_init_journal(void);
int ext4fs_log_gdt(char *gd_table);
int ext4fs_check_journal_state(int recovery_flag);
int ext4fs_log_journal(char *journal_buffer, long int blknr);
int ext4fs_put_metadata(char *metadata_buffer, long int blknr);
int ext4fs_log_journal(char *journal_buffer, uint32_t blknr);
int ext4fs_put_metadata(char *metadata_buffer, uint32_t blknr);
void ext4fs_update_journal(void);
void ext4fs_dump_metadata(void);
void ext4fs_push_revoke_blk(char *buffer);

254
fs/ext4/ext4_write.c
Unescape View File

@ -28,6 +28,26 @@
#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)
{
bg->free_inodes = cpu_to_le16(le16_to_cpu(bg->free_inodes) + 1);
}
static inline void ext4fs_bg_free_blocks_inc(struct ext2_block_group *bg)
{
bg->free_blocks = cpu_to_le16(le16_to_cpu(bg->free_blocks) + 1);
}
static void ext4fs_update(void)
{
short i;
@ -40,14 +60,14 @@ static void ext4fs_update(void)
/* update block groups */
for (i = 0; i < fs->no_blkgrp; i++) {
fs->bgd[i].bg_checksum = ext4fs_checksum_update(i);
put_ext4((uint64_t)((uint64_t)fs->bgd[i].block_id * (uint64_t)fs->blksz),
fs->bgd[i].bg_checksum = cpu_to_le16(ext4fs_checksum_update(i));
put_ext4((uint64_t)le32_to_cpu(fs->bgd[i].block_id) * fs->blksz,
fs->blk_bmaps[i], fs->blksz);
}
/* update inode table groups */
for (i = 0; i < fs->no_blkgrp; i++) {
put_ext4((uint64_t) ((uint64_t)fs->bgd[i].inode_id * (uint64_t)fs->blksz),
put_ext4((uint64_t)le32_to_cpu(fs->bgd[i].inode_id) * fs->blksz,
fs->inode_bmaps[i], fs->blksz);
}
@ -99,11 +119,11 @@ static void delete_single_indirect_block(struct ext2_inode *inode)
{
struct ext2_block_group *bgd = NULL;
static int prev_bg_bmap_idx = -1;
long int blknr;
uint32_t blknr;
int remainder;
int bg_idx;
int status;
unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
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) {
@ -115,8 +135,8 @@ static void delete_single_indirect_block(struct ext2_inode *inode)
/* deleting the single indirect block associated with inode */
if (inode->b.blocks.indir_block != 0) {
debug("SIPB releasing %u\n", inode->b.blocks.indir_block);
blknr = inode->b.blocks.indir_block;
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;
@ -124,18 +144,18 @@ static void delete_single_indirect_block(struct ext2_inode *inode)
bg_idx--;
}
ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
ext4fs_sb_free_blocks_inc(fs->sb);
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
status =
ext4fs_devread((lbaint_t)bgd[bg_idx].block_id *
status = ext4fs_devread(
(lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
fs->sect_perblk, 0, fs->blksz,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal
(journal_buffer, bgd[bg_idx].block_id))
(journal_buffer, le32_to_cpu(bgd[bg_idx].block_id)))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
@ -149,12 +169,12 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
int i;
short status;
static int prev_bg_bmap_idx = -1;
long int blknr;
uint32_t blknr;
int remainder;
int bg_idx;
unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
unsigned int *di_buffer = NULL;
unsigned int *DIB_start_addr = NULL;
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);
@ -171,8 +191,8 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
printf("No memory\n");
return;
}
DIB_start_addr = (unsigned int *)di_buffer;
blknr = inode->b.blocks.double_indir_block;
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++) {
@ -180,21 +200,21 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
break;
debug("DICB releasing %u\n", *di_buffer);
bg_idx = *di_buffer / blk_per_grp;
bg_idx = le32_to_cpu(*di_buffer) / blk_per_grp;
if (fs->blksz == 1024) {
remainder = *di_buffer % blk_per_grp;
remainder = le32_to_cpu(*di_buffer) % blk_per_grp;
if (!remainder)
bg_idx--;
}
ext4fs_reset_block_bmap(*di_buffer,
ext4fs_reset_block_bmap(le32_to_cpu(*di_buffer),
fs->blk_bmaps[bg_idx], bg_idx);
di_buffer++;
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
ext4fs_sb_free_blocks_inc(fs->sb);
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
status = ext4fs_devread((lbaint_t)
bgd[bg_idx].block_id
status = ext4fs_devread(
(lbaint_t)le32_to_cpu(bgd[bg_idx].block_id)
* fs->sect_perblk, 0,
fs->blksz,
journal_buffer);
@ -202,14 +222,14 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[bg_idx].block_id))
le32_to_cpu(bgd[bg_idx].block_id)))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
}
/* removing the parent double indirect block */
blknr = inode->b.blocks.double_indir_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;
@ -217,26 +237,26 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
bg_idx--;
}
ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
ext4fs_sb_free_blocks_inc(fs->sb);
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread((lbaint_t)bgd[bg_idx].block_id *
status = ext4fs_devread((lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
fs->sect_perblk, 0, fs->blksz,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[bg_idx].block_id))
le32_to_cpu(bgd[bg_idx].block_id)))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
debug("DIPB releasing %ld\n", blknr);
debug("DIPB releasing %d\n", blknr);
}
fail:
free(DIB_start_addr);
free(dib_start_addr);
free(journal_buffer);
}
@ -245,14 +265,14 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
int i, j;
short status;
static int prev_bg_bmap_idx = -1;
long int blknr;
uint32_t blknr;
int remainder;
int bg_idx;
unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
unsigned int *tigp_buffer = NULL;
unsigned int *tib_start_addr = NULL;
unsigned int *tip_buffer = NULL;
unsigned int *tipb_start_addr = NULL;
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);
@ -269,8 +289,8 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
printf("No memory\n");
return;
}
tib_start_addr = (unsigned int *)tigp_buffer;
blknr = inode->b.blocks.triple_indir_block;
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++) {
@ -281,33 +301,32 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
tip_buffer = zalloc(fs->blksz);
if (!tip_buffer)
goto fail;
tipb_start_addr = (unsigned int *)tip_buffer;
status = ext4fs_devread((lbaint_t)(*tigp_buffer) *
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 (*tip_buffer == 0)
if (le32_to_cpu(*tip_buffer) == 0)
break;
bg_idx = *tip_buffer / blk_per_grp;
bg_idx = le32_to_cpu(*tip_buffer) / blk_per_grp;
if (fs->blksz == 1024) {
remainder = *tip_buffer % blk_per_grp;
remainder = le32_to_cpu(*tip_buffer) % blk_per_grp;
if (!remainder)
bg_idx--;
}
ext4fs_reset_block_bmap(*tip_buffer,
ext4fs_reset_block_bmap(le32_to_cpu(*tip_buffer),
fs->blk_bmaps[bg_idx],
bg_idx);
tip_buffer++;
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
ext4fs_sb_free_blocks_inc(fs->sb);
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
status =
ext4fs_devread(
(lbaint_t)
bgd[bg_idx].block_id *
(lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
fs->sect_perblk, 0,
fs->blksz,
journal_buffer);
@ -315,8 +334,7 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[bg_idx].
block_id))
le32_to_cpu(bgd[bg_idx].block_id)))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
@ -328,38 +346,38 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
* removing the grand parent blocks
* which is connected to inode
*/
bg_idx = *tigp_buffer / blk_per_grp;
bg_idx = le32_to_cpu(*tigp_buffer) / blk_per_grp;
if (fs->blksz == 1024) {
remainder = *tigp_buffer % blk_per_grp;
remainder = le32_to_cpu(*tigp_buffer) % blk_per_grp;
if (!remainder)
bg_idx--;
}
ext4fs_reset_block_bmap(*tigp_buffer,
ext4fs_reset_block_bmap(le32_to_cpu(*tigp_buffer),
fs->blk_bmaps[bg_idx], bg_idx);
tigp_buffer++;
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
ext4fs_sb_free_blocks_inc(fs->sb);
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
memset(journal_buffer, '\0', fs->blksz);
status =
ext4fs_devread((lbaint_t)
bgd[bg_idx].block_id *
ext4fs_devread(
(lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
fs->sect_perblk, 0,
fs->blksz, journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[bg_idx].block_id))
le32_to_cpu(bgd[bg_idx].block_id)))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
}
/* removing the grand parent triple indirect block */
blknr = inode->b.blocks.triple_indir_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;
@ -367,23 +385,24 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
bg_idx--;
}
ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
ext4fs_sb_free_blocks_inc(fs->sb);
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread((lbaint_t)bgd[bg_idx].block_id *
status = ext4fs_devread(
(lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
fs->sect_perblk, 0, fs->blksz,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[bg_idx].block_id))
le32_to_cpu(bgd[bg_idx].block_id)))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
debug("tigp buffer itself releasing %ld\n", blknr);
debug("tigp buffer itself releasing %d\n", blknr);
}
fail:
free(tib_start_addr);
@ -402,14 +421,14 @@ static int ext4fs_delete_file(int inodeno)
int ibmap_idx;
char *read_buffer = NULL;
char *start_block_address = NULL;
unsigned int no_blocks;
uint32_t no_blocks;
static int prev_bg_bmap_idx = -1;
unsigned int inodes_per_block;
long int blkno;
uint32_t blkno;
unsigned int blkoff;
unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
unsigned int inode_per_grp = ext4fs_root->sblock.inodes_per_group;
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();
@ -423,8 +442,8 @@ static int ext4fs_delete_file(int inodeno)
goto fail;
/* read the block no allocated to a file */
no_blocks = inode.size / fs->blksz;
if (inode.size % fs->blksz)
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) {
@ -450,20 +469,20 @@ static int ext4fs_delete_file(int inodeno)
debug("EXT4_EXTENTS Block releasing %ld: %d\n",
blknr, bg_idx);
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
ext4fs_sb_free_blocks_inc(fs->sb);
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
status =
ext4fs_devread((lbaint_t)
bgd[bg_idx].block_id *
ext4fs_devread(
(lbaint_t)le32_to_cpu(bgd[bg_idx].block_id) *
fs->sect_perblk, 0,
fs->blksz, journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[bg_idx].block_id))
le32_to_cpu(bgd[bg_idx].block_id)))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
@ -479,8 +498,8 @@ static int ext4fs_delete_file(int inodeno)
delete_triple_indirect_block(&inode);
/* read the block no allocated to a file */
no_blocks = inode.size / fs->blksz;
if (inode.size % fs->blksz)
no_blocks = le32_to_cpu(inode.size) / fs->blksz;
if (le32_to_cpu(inode.size) % fs->blksz)
no_blocks++;
for (i = 0; i < no_blocks; i++) {
blknr = read_allocated_block(&inode, i);
@ -494,20 +513,20 @@ static int ext4fs_delete_file(int inodeno)
bg_idx);
debug("ActualB releasing %ld: %d\n", blknr, bg_idx);
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
ext4fs_bg_free_blocks_inc(&bgd[bg_idx]);
ext4fs_sb_free_blocks_inc(fs->sb);
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread((lbaint_t)
bgd[bg_idx].block_id
status = ext4fs_devread(
(lbaint_t)le32_to_cpu(bgd[bg_idx].block_id)
* fs->sect_perblk,
0, fs->blksz,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
bgd[bg_idx].block_id))
le32_to_cpu(bgd[bg_idx].block_id)))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
@ -521,7 +540,7 @@ static int ext4fs_delete_file(int inodeno)
/* get the block no */
inodeno--;
blkno = le32_to_cpu(bgd[ibmap_idx].inode_table_id) +
(inodeno % le32_to_cpu(inode_per_grp)) / inodes_per_block;
(inodeno % inode_per_grp) / inodes_per_block;
/* get the offset of the inode */
blkoff = ((inodeno) % inodes_per_block) * fs->inodesz;
@ -550,15 +569,15 @@ static int ext4fs_delete_file(int inodeno)
/* update the respective inode bitmaps */
inodeno++;
ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx);
bgd[ibmap_idx].free_inodes++;
fs->sb->free_inodes++;
ext4fs_bg_free_inodes_inc(&bgd[ibmap_idx]);
ext4fs_sb_free_inodes_inc(fs->sb);
/* journal backup */
memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread((lbaint_t)bgd[ibmap_idx].inode_id *
status = ext4fs_devread((lbaint_t)le32_to_cpu(bgd[ibmap_idx].inode_id) *
fs->sect_perblk, 0, fs->blksz, journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer, bgd[ibmap_idx].inode_id))
if (ext4fs_log_journal(journal_buffer, le32_to_cpu(bgd[ibmap_idx].inode_id)))
goto fail;
ext4fs_update();
@ -585,7 +604,7 @@ int ext4fs_init(void)
{
short status;
int i;
unsigned int real_free_blocks = 0;
uint32_t real_free_blocks = 0;
struct ext_filesystem *fs = get_fs();
/* populate fs */
@ -606,9 +625,9 @@ int ext4fs_init(void)
/* get total no of blockgroups */
fs->no_blkgrp = (uint32_t)ext4fs_div_roundup(
(ext4fs_root->sblock.total_blocks -
ext4fs_root->sblock.first_data_block),
ext4fs_root->sblock.blocks_per_group);
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);
@ -630,7 +649,8 @@ int ext4fs_init(void)
for (i = 0; i < fs->no_blkgrp; i++) {
status =
ext4fs_devread((lbaint_t)fs->bgd[i].block_id *
ext4fs_devread(
(lbaint_t)le32_to_cpu(fs->bgd[i].block_id) *
fs->sect_perblk, 0,
fs->blksz, (char *)fs->blk_bmaps[i]);
if (status == 0)
@ -648,7 +668,8 @@ int ext4fs_init(void)
}
for (i = 0; i < fs->no_blkgrp; i++) {
status = ext4fs_devread((lbaint_t)fs->bgd[i].inode_id *
status = ext4fs_devread(
(lbaint_t)le32_to_cpu(fs->bgd[i].inode_id) *
fs->sect_perblk,
0, fs->blksz,
(char *)fs->inode_bmaps[i]);
@ -663,9 +684,9 @@ int ext4fs_init(void)
* reboot of a linux kernel
*/
for (i = 0; i < fs->no_blkgrp; i++)
real_free_blocks = real_free_blocks + fs->bgd[i].free_blocks;
if (real_free_blocks != fs->sb->free_blocks)
fs->sb->free_blocks = real_free_blocks;
real_free_blocks = real_free_blocks + le16_to_cpu(fs->bgd[i].free_blocks);
if (real_free_blocks != le32_to_cpu(fs->sb->free_blocks))
fs->sb->free_blocks = cpu_to_le32(real_free_blocks);
return 0;
fail:
@ -679,8 +700,9 @@ void ext4fs_deinit(void)
int i;
struct ext2_inode inode_journal;
struct journal_superblock_t *jsb;
long int blknr;
uint32_t blknr;
struct ext_filesystem *fs = get_fs();
uint32_t new_feature_incompat;
/* free journal */
char *temp_buff = zalloc(fs->blksz);
@ -692,7 +714,7 @@ void ext4fs_deinit(void)
ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz,
temp_buff);
jsb = (struct journal_superblock_t *)temp_buff;
jsb->s_start = cpu_to_be32(0);
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);
@ -701,7 +723,9 @@ void ext4fs_deinit(void)
/* get the superblock */
ext4_read_superblock((char *)fs->sb);
fs->sb->feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
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);
@ -744,7 +768,7 @@ static int ext4fs_write_file(struct ext2_inode *file_inode,
{
int i;
int blockcnt;
unsigned int filesize = le32_to_cpu(file_inode->size);
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;
@ -878,7 +902,7 @@ int ext4fs_write(const char *fname, unsigned char *buffer,
}
blocks_remaining = blks_reqd_for_file;
/* test for available space in partition */
if (fs->sb->free_blocks < blks_reqd_for_file) {
if (le32_to_cpu(fs->sb->free_blocks) < blks_reqd_for_file) {
printf("Not enough space on partition !!!\n");
goto fail;
}
@ -889,25 +913,25 @@ int ext4fs_write(const char *fname, unsigned char *buffer,
if (!inode_buffer)
goto fail;
file_inode = (struct ext2_inode *)inode_buffer;
file_inode->mode = S_IFREG | S_IRWXU |
S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH;
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 = timestamp;
file_inode->atime = timestamp;
file_inode->ctime = timestamp;
file_inode->nlinks = 1;
file_inode->size = sizebytes;
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 = (blks_reqd_for_file * fs->blksz) >>
fs->dev_desc->log2blksz;
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 / ext4fs_root->sblock.inodes_per_group;
ibmap_idx = inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
inodeno--;
itable_blkno = le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) +
(inodeno % le32_to_cpu(sblock->inodes_per_group)) /
@ -926,7 +950,7 @@ int ext4fs_write(const char *fname, unsigned char *buffer,
printf("Error in copying content\n");
goto fail;
}
ibmap_idx = parent_inodeno / ext4fs_root->sblock.inodes_per_group;
ibmap_idx = parent_inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
parent_inodeno--;
parent_itable_blkno = le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) +
(parent_inodeno %

2
include/ext_common.h
Unescape View File

@ -52,7 +52,7 @@
#define LOG2_BLOCK_SIZE(data) (le32_to_cpu \
(data->sblock.log2_block_size) \
+ EXT2_MIN_BLOCK_LOG_SIZE)
#define INODE_SIZE_FILESYSTEM(data) (le32_to_cpu \
#define INODE_SIZE_FILESYSTEM(data) (le16_to_cpu \
(data->sblock.inode_size))
#define EXT2_FT_DIR 2

Write Preview
Loading…
Cancel
Save