]> git.sur5r.net Git - u-boot/commitdiff
ext4: fix endianess problems in ext4 write support
authorMichael Walle <michael@walle.cc>
Thu, 1 Sep 2016 09:21:40 +0000 (11:21 +0200)
committerTom Rini <trini@konsulko.com>
Fri, 23 Sep 2016 13:02:04 +0000 (09:02 -0400)
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>
fs/ext4/ext4_common.c
fs/ext4/ext4_common.h
fs/ext4/ext4_journal.c
fs/ext4/ext4_journal.h
fs/ext4/ext4_write.c
include/ext_common.h

index e8ed30aa599fe1fdc3fb1dea2aba8b71dd31e2d6..caec9d45779bfedbc98ccbf5e40bd11b47df84fa 100644 (file)
 
 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;
        }
index 48fd2ac51dbb2761f233122ba7c801e946c94ef2..370a7175ca72e4e14b8f1ba08315f4c18e43884d 100644 (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);
index 3f613351a4328b7a76ed87838dbd965c50038037..cf14049c32931465630ab4e3832f3816226c7a15 100644 (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),
index d54165ce19cdd2ab2f6256d1c9d09d90b7fd48f5..3d05ad531546d993cea1da255fd892c48aa192d6 100644 (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);
index 1169ee344b8d4337e8cc6cfce7efc0d1735c05c0..fac3222ef8f2e093d7bd13bd358fb32af47c26fa 100644 (file)
 #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 %
index 3220091b9840bc312aaedc4392f3a96004fb053a..4cd2aa7b5accfd43d467427e47db685ff7d50b40 100644 (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