[U-Boot] [RFC PATCH 3/4] ext4: fix endianess problems in ext4 write support
Michael Walle
michael at walle.cc
Fri Aug 12 15:16:20 CEST 2016
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 at walle.cc>
---
Ok this patch is huge, please comment. I know, checkpatch fails because
there are longer lines than 80 characters. I don't want do be rude, but the
coding style is awful :/ Eg.
http://git.denx.de/?p=u-boot.git;a=blob;f=fs/ext4/ext4_common.c;h=eb49fce04c5a290e839575945da722bc97d2f670;hb=HEAD#l440
http://git.denx.de/?p=u-boot.git;a=blob;f=fs/ext4/ext4_write.c;h=e027916763f9b52937c7fe13f1698b67b94eb901;hb=HEAD#l137
Many ugly places seems to come from the 80 characters limit. Most of the
code looks like its right-aligned. I know there is a valid point for having
this limit, eg refactor code into small functions. And frankly, the ext4
write code badly needs such a refactoring. But I won't and can't do it. I
can resend a new version which meet the 80 character restriction, but it
won't make the code easier to read. And believe me, it is already hard to
do it.
Ok, back to business. Sparse really helped to find the places where the
byteswaps were missing once you annotated it correctly with the
__le16/__le32 types. If someone want to do check again, just run
make C=1
See Documentation/sparse.txt in the linux kernel for more information. I've
done a short test, to verify I can (over)write a 700kB file. No cornertests
etc.
fs/ext4/ext4_common.c | 260 ++++++++++++++++++++++++++-----------------------
fs/ext4/ext4_common.h | 4 +-
fs/ext4/ext4_journal.c | 15 +--
fs/ext4/ext4_journal.h | 4 +-
fs/ext4/ext4_write.c | 195 +++++++++++++++++++------------------
include/ext_common.h | 2 +-
6 files changed, 251 insertions(+), 229 deletions(-)
diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c
index e8ed30a..4eb4e18 100644
--- a/fs/ext4/ext4_common.c
+++ b/fs/ext4/ext4_common.c
@@ -33,19 +33,22 @@
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;
+#define DEC_LE16(x) (x = cpu_to_le16(le16_to_cpu(x) - 1))
+#define DEC_LE32(x) (x = cpu_to_le32(le32_to_cpu(x) - 1))
+
#if defined(CONFIG_EXT4_WRITE)
uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n)
{
@@ -112,7 +115,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 +252,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 +277,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 +292,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 +326,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 +337,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 +364,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 +403,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 +412,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 +437,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 +474,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 +484,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 +543,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 +551,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 +729,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 +789,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 +799,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 +855,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 +872,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 +890,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 *
+ DEC_LE16(bgd[i].free_blocks);
+ DEC_LE32(fs->sb->free_blocks);
+ 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 +934,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 +954,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--;
+ DEC_LE16(bgd[bg_idx].free_blocks);
+ DEC_LE32(fs->sb->free_blocks);
goto success;
}
success:
@@ -975,7 +988,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 +1003,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 +1020,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 *
+ DEC_LE16(bgd[i].free_inodes);
+ DEC_LE16(bgd[i].bg_itable_unused);
+ DEC_LE32(fs->sb->free_inodes);
+ 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 +1043,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 +1065,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 +1080,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--;
+ DEC_LE16(bgd[ibmap_idx].free_inodes);
+ DEC_LE16(bgd[ibmap_idx].bg_itable_unused);
+ DEC_LE32(fs->sb->free_inodes);
goto success;
}
@@ -1097,8 +1109,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 +1140,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 +1153,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 +1170,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 +1217,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 +1240,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 +1260,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 +1278,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 +1313,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 +1331,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 +1347,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 +1376,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 +1401,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 +1432,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 +1444,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 +1453,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 +2046,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 +2061,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 +2246,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;
}
diff --git a/fs/ext4/ext4_common.h b/fs/ext4/ext4_common.h
index 48fd2ac..370a717 100644
--- a/fs/ext4/ext4_common.h
+++ b/fs/ext4/ext4_common.h
@@ -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);
diff --git a/fs/ext4/ext4_journal.c b/fs/ext4/ext4_journal.c
index 3f61335..cf14049 100644
--- a/fs/ext4/ext4_journal.c
+++ b/fs/ext4/ext4_journal.c
@@ -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),
diff --git a/fs/ext4/ext4_journal.h b/fs/ext4/ext4_journal.h
index d54165c..3d05ad5 100644
--- a/fs/ext4/ext4_journal.h
+++ b/fs/ext4/ext4_journal.h
@@ -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);
diff --git a/fs/ext4/ext4_write.c b/fs/ext4/ext4_write.c
index 1169ee3..d03d692 100644
--- a/fs/ext4/ext4_write.c
+++ b/fs/ext4/ext4_write.c
@@ -28,6 +28,9 @@
#include <div64.h>
#include "ext4_common.h"
+#define INC_LE16(x) (x = cpu_to_le16(le16_to_cpu(x) + 1))
+#define INC_LE32(x) (x = cpu_to_le32(le32_to_cpu(x) + 1))
+
static void ext4fs_update(void)
{
short i;
@@ -40,14 +43,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 +102,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 +118,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 +127,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++;
+ INC_LE16(bgd[bg_idx].free_blocks);
+ INC_LE32(fs->sb->free_blocks);
/* 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,10 +152,10 @@ 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;
+ uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
unsigned int *di_buffer = NULL;
unsigned int *DIB_start_addr = NULL;
struct ext2_block_group *bgd = NULL;
@@ -172,7 +175,7 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
return;
}
DIB_start_addr = (unsigned int *)di_buffer;
- blknr = inode->b.blocks.double_indir_block;
+ 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++) {
@@ -189,12 +192,12 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
ext4fs_reset_block_bmap(*di_buffer,
fs->blk_bmaps[bg_idx], bg_idx);
di_buffer++;
- bgd[bg_idx].free_blocks++;
- fs->sb->free_blocks++;
+ INC_LE16(bgd[bg_idx].free_blocks);
+ INC_LE32(fs->sb->free_blocks);
/* 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 +205,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,23 +220,23 @@ 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++;
+ INC_LE16(bgd[bg_idx].free_blocks);
+ INC_LE32(fs->sb->free_blocks);
/* 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);
@@ -245,10 +248,10 @@ 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;
+ uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
unsigned int *tigp_buffer = NULL;
unsigned int *tib_start_addr = NULL;
unsigned int *tip_buffer = NULL;
@@ -270,7 +273,7 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
return;
}
tib_start_addr = (unsigned int *)tigp_buffer;
- blknr = inode->b.blocks.triple_indir_block;
+ 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++) {
@@ -300,14 +303,13 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
bg_idx);
tip_buffer++;
- bgd[bg_idx].free_blocks++;
- fs->sb->free_blocks++;
+ INC_LE16(bgd[bg_idx].free_blocks);
+ INC_LE32(fs->sb->free_blocks);
/* 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 +317,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;
}
@@ -338,28 +339,28 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
fs->blk_bmaps[bg_idx], bg_idx);
tigp_buffer++;
- bgd[bg_idx].free_blocks++;
- fs->sb->free_blocks++;
+ INC_LE16(bgd[bg_idx].free_blocks);
+ INC_LE32(fs->sb->free_blocks);
/* 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 +368,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++;
+ INC_LE16(bgd[bg_idx].free_blocks);
+ INC_LE32(fs->sb->free_blocks);
/* 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 +404,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 +425,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 +452,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++;
+ INC_LE16(bgd[bg_idx].free_blocks);
+ INC_LE32(fs->sb->free_blocks);
/* 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 +481,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 +496,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++;
+ INC_LE16(bgd[bg_idx].free_blocks);
+ INC_LE32(fs->sb->free_blocks);
/* 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 +523,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 +552,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++;
+ INC_LE16(bgd[ibmap_idx].free_inodes);
+ INC_LE32(fs->sb->free_inodes);
/* 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 +587,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 +608,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 +632,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 +651,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 +667,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 +683,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 +697,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 +706,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 +751,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 +885,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 +896,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 +933,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 %
diff --git a/include/ext_common.h b/include/ext_common.h
index 3220091..4cd2aa7 100644
--- a/include/ext_common.h
+++ b/include/ext_common.h
@@ -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
--
2.1.4
More information about the U-Boot
mailing list