Add type cast to eliminate compiler warning messages.

diff --git a/lwext4/ext4.c b/lwext4/ext4.c
index d7af585d8180c12957125b7684ef8fc8f522bd93..236cb09e5d4c276fb13bdceae6aba60ed70ea743 100644 (file)
--- a/lwext4/ext4.c
+++ b/lwext4/ext4.c
@@ -1647,10 +1647,11 @@ int ext4_fread(ext4_file *f, void *buf, size_t size, size_t *rcnt)
        f->fsize = ext4_inode_get_size(sb, ref.inode);
 
        block_size = ext4_sb_get_block_size(sb);
-       size = size > (f->fsize - f->fpos) ? (f->fsize - f->fpos) : size;
+       size = ((uint64_t)size > (f->fsize - f->fpos))
+               ? ((size_t)(f->fsize - f->fpos)) : size;
 
-       iblock_idx = (f->fpos) / block_size;
-       iblock_last = (f->fpos + size) / block_size;
+       iblock_idx = (uint32_t)((f->fpos) / block_size);
+       iblock_last = (uint32_t)((f->fpos + size) / block_size);
        unalg = (f->fpos) % block_size;
 
        /*If the size of symlink is smaller than 60 bytes*/
@@ -1662,8 +1663,8 @@ int ext4_fread(ext4_file *f, void *buf, size_t size, size_t *rcnt)
                char *content = (char *)ref.inode->blocks;
                if (f->fpos < f->fsize) {
                        size_t len = size;
-                       if (unalg + size > f->fsize)
-                               len = f->fsize - unalg;
+                       if (unalg + size > (uint32_t)f->fsize)
+                               len = (uint32_t)f->fsize - unalg;
                        memcpy(buf, content + unalg, len);
                        if (rcnt)
                                *rcnt = len;
@@ -1808,9 +1809,9 @@ int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
        f->fsize = ext4_inode_get_size(sb, ref.inode);
        block_size = ext4_sb_get_block_size(sb);
 
-       iblock_last = (f->fpos + size) / block_size;
-       iblk_idx = (f->fpos) / block_size;
-       ifile_blocks = (f->fsize + block_size - 1) / block_size;
+       iblock_last = (uint32_t)((f->fpos + size) / block_size);
+       iblk_idx = (uint32_t)(f->fpos / block_size);
+       ifile_blocks = (uint32_t)((f->fsize + block_size - 1) / block_size);
 
        unalg = (f->fpos) % block_size;
 

diff --git a/lwext4/ext4_balloc.c b/lwext4/ext4_balloc.c
index 31be301af48f2210d105d55bd20e440ea3a5006f..2980e2686c030c5fbbdedfd4fb5c8cae7e37ae20 100644 (file)
--- a/lwext4/ext4_balloc.c
+++ b/lwext4/ext4_balloc.c
@@ -58,7 +58,7 @@ uint32_t ext4_balloc_get_bgid_of_block(struct ext4_sblock *s,
        if (ext4_get32(s, first_data_block) && baddr)
                baddr--;
 
-       return baddr / ext4_get32(s, blocks_per_group);
+       return (uint32_t)(baddr / ext4_get32(s, blocks_per_group));
 }
 
 /**@brief Compute the starting block address of a block group

diff --git a/lwext4/ext4_block_group.h b/lwext4/ext4_block_group.h
index 92d57dfb97314c6128412d616d1632594f55051e..715967e99fee7c6c3e9f789aef503d7a36506790 100644 (file)
--- a/lwext4/ext4_block_group.h
+++ b/lwext4/ext4_block_group.h
@@ -79,7 +79,7 @@ static inline void ext4_bg_set_block_bitmap(struct ext4_bgroup *bg,
                                            struct ext4_sblock *s, uint64_t blk)
 {
 
-       bg->block_bitmap_lo = to_le32(blk);
+       bg->block_bitmap_lo = to_le32((uint32_t)blk);
        if (ext4_sb_get_desc_size(s) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
                bg->block_bitmap_hi = to_le32(blk >> 32);
 
@@ -111,7 +111,7 @@ static inline uint64_t ext4_bg_get_inode_bitmap(struct ext4_bgroup *bg,
 static inline void ext4_bg_set_inode_bitmap(struct ext4_bgroup *bg,
                                            struct ext4_sblock *s, uint64_t blk)
 {
-       bg->inode_bitmap_lo = to_le32(blk);
+       bg->inode_bitmap_lo = to_le32((uint32_t)blk);
        if (ext4_sb_get_desc_size(s) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
                bg->inode_bitmap_hi = to_le32(blk >> 32);
 
@@ -145,7 +145,7 @@ static inline void
 ext4_bg_set_inode_table_first_block(struct ext4_bgroup *bg,
                                    struct ext4_sblock *s, uint64_t blk)
 {
-       bg->inode_table_first_block_lo = to_le32(blk);
+       bg->inode_table_first_block_lo = to_le32((uint32_t)blk);
        if (ext4_sb_get_desc_size(s) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
                bg->inode_table_first_block_hi = to_le32(blk >> 32);
 }

diff --git a/lwext4/ext4_dir.c b/lwext4/ext4_dir.c
index 1caa73b2928c8d05c83decbb5a69042cf5bf01d4..f26dc6d424a172ef163ef6c1d29f85224e8f806f 100644 (file)
--- a/lwext4/ext4_dir.c
+++ b/lwext4/ext4_dir.c
@@ -217,7 +217,7 @@ static int ext4_dir_iterator_seek(struct ext4_dir_iter *it, uint64_t pos)
        /* Compute next block address */
        uint32_t block_size = ext4_sb_get_block_size(sb);
        uint64_t current_blk_idx = it->curr_off / block_size;
-       uint32_t next_blk_idx = pos / block_size;
+       uint32_t next_blk_idx = (uint32_t)(pos / block_size);
 
        /*
         * If we don't have a block or are moving across block boundary,
@@ -316,7 +316,7 @@ void ext4_dir_write_entry(struct ext4_sblock *sb, struct ext4_dir_en *en,
        /* Set basic attributes */
        ext4_dir_en_set_inode(en, child->index);
        ext4_dir_en_set_entry_len(en, entry_len);
-       ext4_dir_en_set_name_len(sb, en, name_len);
+       ext4_dir_en_set_name_len(sb, en, (uint16_t)name_len);
 
        /* Write name */
        memcpy(en->name, name, name_len);
@@ -353,8 +353,8 @@ int ext4_dir_add_entry(struct ext4_inode_ref *parent, const char *name,
        uint32_t iblock = 0;
        ext4_fsblk_t fblock = 0;
        uint32_t block_size = ext4_sb_get_block_size(sb);
-       uint32_t inode_size = ext4_inode_get_size(sb, parent->inode);
-       uint32_t total_blocks = inode_size / block_size;
+       uint64_t inode_size = ext4_inode_get_size(sb, parent->inode);
+       uint32_t total_blocks = (uint32_t)(inode_size / block_size);
 
        /* Find block, where is space for new entry and try to add */
        bool success = false;
@@ -462,8 +462,8 @@ int ext4_dir_find_entry(struct ext4_dir_search_result *result,
        uint32_t iblock;
        ext4_fsblk_t fblock;
        uint32_t block_size = ext4_sb_get_block_size(sb);
-       uint32_t inode_size = ext4_inode_get_size(sb, parent->inode);
-       uint32_t total_blocks = inode_size / block_size;
+       uint64_t inode_size = ext4_inode_get_size(sb, parent->inode);
+       uint32_t total_blocks = (uint32_t)(inode_size / block_size);
 
        /* Walk through all data blocks */
        for (iblock = 0; iblock < total_blocks; ++iblock) {

diff --git a/lwext4/ext4_dir_idx.c b/lwext4/ext4_dir_idx.c
index 3a156b6c5851552c2fda254a5d3877ff42b36cee..81da0de330effafb75c881664cbf4e2fa72547d0 100644 (file)
--- a/lwext4/ext4_dir_idx.c
+++ b/lwext4/ext4_dir_idx.c
@@ -962,7 +962,7 @@ static int ext4_dir_dx_split_data(struct ext4_inode_ref *inode_ref,
        while ((void *)de < (void *)(old_data_block->data + block_size)) {
                /* Read only valid entries */
                if (ext4_dir_en_get_inode(de) && de->name_len) {
-                       uint8_t len = ext4_dir_en_get_name_len(sb, de);
+                       uint16_t len = ext4_dir_en_get_name_len(sb, de);
                        rc = ext4_dir_dx_hash_string(&hinfo_tmp, len,
                                                     (char *)de->name);
                        if (rc != EOK) {

diff --git a/lwext4/ext4_extent.c b/lwext4/ext4_extent.c
index 2c0ad527d1978967737c2cf949c5b4a9a98acd54..f53733d10d9073f3cf4367b3ab8cc677e0127c90 100644 (file)
--- a/lwext4/ext4_extent.c
+++ b/lwext4/ext4_extent.c
@@ -170,9 +170,9 @@ static void ext4_ext_free_blocks(struct ext4_inode_ref *inode_ref,
        ext4_balloc_free_blocks(inode_ref, block, count);
 }
 
-static size_t ext4_ext_space_block(struct ext4_inode_ref *inode_ref)
+static uint16_t ext4_ext_space_block(struct ext4_inode_ref *inode_ref)
 {
-       size_t size;
+       uint16_t size;
        uint32_t block_size = ext4_sb_get_block_size(&inode_ref->fs->sb);
 
        size = (block_size - sizeof(struct ext4_extent_header)) /
@@ -184,9 +184,9 @@ static size_t ext4_ext_space_block(struct ext4_inode_ref *inode_ref)
        return size;
 }
 
-static size_t ext4_ext_space_block_idx(struct ext4_inode_ref *inode_ref)
+static uint16_t ext4_ext_space_block_idx(struct ext4_inode_ref *inode_ref)
 {
-       size_t size;
+       uint16_t size;
        uint32_t block_size = ext4_sb_get_block_size(&inode_ref->fs->sb);
 
        size = (block_size - sizeof(struct ext4_extent_header)) /
@@ -198,9 +198,9 @@ static size_t ext4_ext_space_block_idx(struct ext4_inode_ref *inode_ref)
        return size;
 }
 
-static size_t ext4_ext_space_root(struct ext4_inode_ref *inode_ref)
+static uint16_t ext4_ext_space_root(struct ext4_inode_ref *inode_ref)
 {
-       size_t size;
+       uint16_t size;
 
        size = sizeof(inode_ref->inode->blocks);
        size -= sizeof(struct ext4_extent_header);
@@ -212,9 +212,9 @@ static size_t ext4_ext_space_root(struct ext4_inode_ref *inode_ref)
        return size;
 }
 
-static size_t ext4_ext_space_root_idx(struct ext4_inode_ref *inode_ref)
+static uint16_t ext4_ext_space_root_idx(struct ext4_inode_ref *inode_ref)
 {
-       size_t size;
+       uint16_t size;
 
        size = sizeof(inode_ref->inode->blocks);
        size -= sizeof(struct ext4_extent_header);
@@ -226,10 +226,10 @@ static size_t ext4_ext_space_root_idx(struct ext4_inode_ref *inode_ref)
        return size;
 }
 
-static size_t ext4_ext_max_entries(struct ext4_inode_ref *inode_ref,
+static uint16_t ext4_ext_max_entries(struct ext4_inode_ref *inode_ref,
                                   uint32_t depth)
 {
-       size_t max;
+       uint16_t max;
 
        if (depth == ext_depth(inode_ref->inode)) {
                if (depth == 0)
@@ -1730,7 +1730,7 @@ static int ext4_ext_zero_unwritten_range(struct ext4_inode_ref *inode_ref,
        return err;
 }
 
-int ext4_extent_get_blocks(struct ext4_inode_ref *inode_ref, ext4_fsblk_t iblock,
+int ext4_extent_get_blocks(struct ext4_inode_ref *inode_ref, ext4_lblk_t iblock,
                        uint32_t max_blocks, ext4_fsblk_t *result, bool create,
                        uint32_t *blocks_count)
 {
@@ -1740,7 +1740,8 @@ int ext4_extent_get_blocks(struct ext4_inode_ref *inode_ref, ext4_fsblk_t iblock
        int err = EOK;
        int32_t depth;
        uint32_t allocated = 0;
-       ext4_fsblk_t next, newblock;
+       ext4_lblk_t next;
+       ext4_fsblk_t newblock;
 
        if (result)
                *result = 0;

diff --git a/lwext4/ext4_extent.h b/lwext4/ext4_extent.h
index 2577b24a2c59d6b9bdec5946eef6fe00e787c61f..1d4ddf153628f021f3909574c9a18750e0c2e982 100644 (file)
--- a/lwext4/ext4_extent.h
+++ b/lwext4/ext4_extent.h
@@ -265,7 +265,7 @@ static inline void ext4_extent_tree_init(struct ext4_inode_ref *inode_ref)
 
 
 /**TODO:  */
-int ext4_extent_get_blocks(struct ext4_inode_ref *inode_ref, ext4_fsblk_t iblock,
+int ext4_extent_get_blocks(struct ext4_inode_ref *inode_ref, ext4_lblk_t iblock,
                           uint32_t max_blocks, ext4_fsblk_t *result, bool create,
                           uint32_t *blocks_count);
 

diff --git a/lwext4/ext4_fs.c b/lwext4/ext4_fs.c
index 1d807f2821dd002814e71eeef404c990d783dfba..392728dd8040765e6026f8564d03e1416ac9ce47 100644 (file)
--- a/lwext4/ext4_fs.c
+++ b/lwext4/ext4_fs.c
@@ -328,10 +328,10 @@ static int ext4_fs_init_block_bitmap(struct ext4_block_group_ref *bg_ref)
                 * to make sure we calculate the right free blocks
                 */
 
-               group_blocks = ext4_sb_get_blocks_cnt(sb);
-               group_blocks -= ext4_get32(sb, first_data_block);
-               group_blocks -= ext4_get32(sb, blocks_per_group) *
-                               (ext4_block_group_cnt(sb) - 1);
+               group_blocks = (uint32_t)(ext4_sb_get_blocks_cnt(sb) -
+                                         ext4_get32(sb, first_data_block) -
+                                         ext4_get32(sb, blocks_per_group) *
+                                         (ext4_block_group_cnt(sb) - 1));
        } else {
                group_blocks = ext4_get32(sb, blocks_per_group);
        }
@@ -339,16 +339,19 @@ static int ext4_fs_init_block_bitmap(struct ext4_block_group_ref *bg_ref)
        bool in_bg;
        in_bg = ext4_block_in_group(sb, bmp_blk, bg_ref->index);
        if (!flex_bg || in_bg)
-               ext4_bmap_bit_set(block_bitmap.data, bmp_blk - first_bg);
+               ext4_bmap_bit_set(block_bitmap.data,
+                                 (uint32_t)(bmp_blk - first_bg));
 
        in_bg = ext4_block_in_group(sb, bmp_inode, bg_ref->index);
        if (!flex_bg || in_bg)
-               ext4_bmap_bit_set(block_bitmap.data, bmp_inode - first_bg);
+               ext4_bmap_bit_set(block_bitmap.data,
+                                 (uint32_t)(bmp_inode - first_bg));
 
         for (i = inode_table; i < inode_table + inode_table_bcnt; i++) {
                in_bg = ext4_block_in_group(sb, i, bg_ref->index);
                if (!flex_bg || in_bg)
-                       ext4_bmap_bit_set(block_bitmap.data, i - first_bg);
+                       ext4_bmap_bit_set(block_bitmap.data,
+                                         (uint32_t)(i - first_bg));
        }
         /*
          * Also if the number of blocks within the group is
@@ -727,7 +730,7 @@ __ext4_fs_get_inode_ref(struct ext4_fs *fs, uint32_t index,
        }
 
        /* Load block address, where i-node table is located */
-       uint32_t inode_table_start =
+       ext4_fsblk_t inode_table_start =
            ext4_bg_get_inode_table_first_block(bg_ref.block_group, &fs->sb);
 
        /* Put back block group reference (not needed more) */
@@ -1089,7 +1092,7 @@ static int ext4_fs_release_inode_block(struct ext4_inode_ref *inode_ref,
                return EIO;
 
        /* Compute offsets for the topmost level */
-       uint64_t block_offset_in_level =
+       uint32_t block_offset_in_level =
            iblock - fs->inode_block_limits[level - 1];
        ext4_fsblk_t current_block =
            ext4_inode_get_indirect_block(inode, level - 1);
@@ -1172,7 +1175,8 @@ int ext4_fs_truncate_inode(struct ext4_inode_ref *inode_ref, uint64_t new_size)
        if (v && old_size < sizeof(inode_ref->inode->blocks) &&
            !ext4_inode_get_blocks_count(sb, inode_ref->inode)) {
                char *content = (char *)inode_ref->inode->blocks + new_size;
-               memset(content , 0, sizeof(inode_ref->inode->blocks) - new_size);
+               memset(content, 0,
+                      sizeof(inode_ref->inode->blocks) - (uint32_t)new_size);
                ext4_inode_set_size(inode_ref->inode, new_size);
                inode_ref->dirty = true;
 
@@ -1181,8 +1185,8 @@ int ext4_fs_truncate_inode(struct ext4_inode_ref *inode_ref, uint64_t new_size)
 
        /* Compute how many blocks will be released */
        uint32_t block_size = ext4_sb_get_block_size(sb);
-       uint32_t new_blocks_cnt = (new_size + block_size - 1) / block_size;
-       uint32_t old_blocks_cnt = (old_size + block_size - 1) / block_size;
+       uint32_t new_blocks_cnt = (uint32_t)((new_size + block_size - 1) / block_size);
+       uint32_t old_blocks_cnt = (uint32_t)((old_size + block_size - 1) / block_size);
        uint32_t diff_blocks_cnt = old_blocks_cnt - new_blocks_cnt;
 #if CONFIG_EXTENT_ENABLE
        if ((ext4_sb_feature_incom(sb, EXT4_FINCOM_EXTENTS)) &&
@@ -1242,7 +1246,7 @@ int ext4_fs_indirect_find_goal(struct ext4_inode_ref *inode_ref,
 
        uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode);
        uint32_t block_size = ext4_sb_get_block_size(sb);
-       uint32_t iblock_cnt = inode_size / block_size;
+       uint32_t iblock_cnt = (uint32_t)(inode_size / block_size);
 
        if (inode_size % block_size != 0)
                iblock_cnt++;
@@ -1362,7 +1366,7 @@ static int ext4_fs_get_inode_dblk_idx_internal(struct ext4_inode_ref *inode_ref,
                return EIO;
 
        /* Compute offsets for the topmost level */
-       uint64_t blk_off_in_lvl =  iblock - fs->inode_block_limits[l - 1];
+       uint32_t blk_off_in_lvl =  iblock - fs->inode_block_limits[l - 1];
        current_block = ext4_inode_get_indirect_block(inode, l - 1);
        uint32_t off_in_blk = blk_off_in_lvl / fs->inode_blocks_per_level[l - 1];
 
@@ -1434,7 +1438,7 @@ int ext4_fs_init_inode_dblk_idx(struct ext4_inode_ref *inode_ref,
 }
 
 static int ext4_fs_set_inode_data_block_index(struct ext4_inode_ref *inode_ref,
-                                      uint64_t iblock, ext4_fsblk_t fblock)
+                                      uint32_t iblock, ext4_fsblk_t fblock)
 {
        struct ext4_fs *fs = inode_ref->fs;
 
@@ -1472,7 +1476,7 @@ static int ext4_fs_set_inode_data_block_index(struct ext4_inode_ref *inode_ref,
        uint32_t block_size = ext4_sb_get_block_size(&fs->sb);
 
        /* Compute offsets for the topmost level */
-       uint64_t blk_off_in_lvl =  iblock - fs->inode_block_limits[l - 1];
+       uint32_t blk_off_in_lvl =  iblock - fs->inode_block_limits[l - 1];
        ext4_fsblk_t current_block =
                        ext4_inode_get_indirect_block(inode_ref->inode, l - 1);
        uint32_t off_in_blk = blk_off_in_lvl / fs->inode_blocks_per_level[l - 1];
@@ -1495,7 +1499,8 @@ static int ext4_fs_set_inode_data_block_index(struct ext4_inode_ref *inode_ref,
                        return rc;
 
                /* Update i-node */
-               ext4_inode_set_indirect_block(inode_ref->inode, l - 1, new_blk);
+               ext4_inode_set_indirect_block(inode_ref->inode, l - 1,
+                               (uint32_t)new_blk);
                inode_ref->dirty = true;
 
                /* Load newly allocated block */
@@ -1610,7 +1615,7 @@ int ext4_fs_append_inode_dblk(struct ext4_inode_ref *inode_ref,
                struct ext4_sblock *sb = &inode_ref->fs->sb;
                uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode);
                uint32_t block_size = ext4_sb_get_block_size(sb);
-               *iblock = (inode_size + block_size - 1) / block_size;
+               *iblock = (uint32_t)((inode_size + block_size - 1) / block_size);
 
                rc = ext4_extent_get_blocks(inode_ref, *iblock, 1,
                                                &current_fsblk, true, NULL);
@@ -1636,7 +1641,7 @@ int ext4_fs_append_inode_dblk(struct ext4_inode_ref *inode_ref,
                inode_size += block_size - (inode_size % block_size);
 
        /* Logical blocks are numbered from 0 */
-       uint32_t new_block_idx = inode_size / block_size;
+       uint32_t new_block_idx = (uint32_t)(inode_size / block_size);
 
        /* Allocate new physical block */
        ext4_fsblk_t goal, phys_block;

diff --git a/lwext4/ext4_inode.c b/lwext4/ext4_inode.c
index 696a8d782f0004f16fb78b68de5057b2e1c98fd4..9b6eb87650a0e3e879eeb3457db6dace8bc94baa 100644 (file)
--- a/lwext4/ext4_inode.c
+++ b/lwext4/ext4_inode.c
@@ -216,7 +216,7 @@ int ext4_inode_set_blocks_count(struct ext4_sblock *sb,
        max = ~max >> 32;
 
        if (count <= max) {
-               inode->blocks_count_lo = to_le32(count);
+               inode->blocks_count_lo = to_le32((uint32_t)count);
                inode->osd2.linux2.blocks_high = 0;
                ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
 
@@ -232,8 +232,8 @@ int ext4_inode_set_blocks_count(struct ext4_sblock *sb,
        max = ~max >> 16;
 
        if (count <= max) {
-               inode->blocks_count_lo = to_le32(count);
-               inode->osd2.linux2.blocks_high = to_le16(count >> 32);
+               inode->blocks_count_lo = to_le32((uint32_t)count);
+               inode->osd2.linux2.blocks_high = to_le16((uint16_t)(count >> 32));
                ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
        } else {
                uint32_t block_count = ext4_sb_get_block_size(sb);
@@ -241,8 +241,8 @@ int ext4_inode_set_blocks_count(struct ext4_sblock *sb,
 
                ext4_inode_set_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
                count = count >> (block_bits - 9);
-               inode->blocks_count_lo = to_le32(count);
-               inode->osd2.linux2.blocks_high = to_le16(count >> 32);
+               inode->blocks_count_lo = to_le32((uint32_t)count);
+               inode->osd2.linux2.blocks_high = to_le16((uint16_t)(count >> 32));
        }
 
        return EOK;
@@ -293,7 +293,7 @@ void ext4_inode_set_file_acl(struct ext4_inode *inode, struct ext4_sblock *sb,
        inode->file_acl_lo = to_le32((acl << 32) >> 32);
 
        if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_LINUX)
-               inode->osd2.linux2.file_acl_high = to_le16(acl >> 32);
+               inode->osd2.linux2.file_acl_high = to_le16((uint16_t)(acl >> 32));
 }
 
 uint32_t ext4_inode_get_direct_block(struct ext4_inode *inode, uint32_t idx)

diff --git a/lwext4/ext4_journal.c b/lwext4/ext4_journal.c
index 86366a1bf044a5792dea5395908bc37a6c7f104c..73a84bfc7a2e0263ce52885bd0b7f19bea1469f1 100644 (file)
--- a/lwext4/ext4_journal.c
+++ b/lwext4/ext4_journal.c
@@ -701,7 +701,7 @@ jbd_write_block_tag(struct jbd_fs *jbd_fs,
                                     JBD_FEATURE_INCOMPAT_CSUM_V3)) {
                struct jbd_block_tag3 *tag = __tag;
                memset(tag, 0, sizeof(struct jbd_block_tag3));
-               jbd_set32(tag, blocknr, tag_info->block);
+               jbd_set32(tag, blocknr, (uint32_t)tag_info->block);
                if (JBD_HAS_INCOMPAT_FEATURE(&jbd_fs->sb,
                                             JBD_FEATURE_INCOMPAT_64BIT))
                        jbd_set32(tag, blocknr_high, tag_info->block >> 32);
@@ -727,7 +727,7 @@ jbd_write_block_tag(struct jbd_fs *jbd_fs,
        } else {
                struct jbd_block_tag *tag = __tag;
                memset(tag, 0, sizeof(struct jbd_block_tag));
-               jbd_set32(tag, blocknr, tag_info->block);
+               jbd_set32(tag, blocknr, (uint32_t)tag_info->block);
                if (JBD_HAS_INCOMPAT_FEATURE(&jbd_fs->sb,
                                             JBD_FEATURE_INCOMPAT_64BIT))
                        jbd_set32(tag, blocknr_high, tag_info->block >> 32);
@@ -1997,7 +1997,7 @@ again:
                } else {
                        uint32_t *blocks =
                                (uint32_t *)blocks_entry;
-                       *blocks = to_be32(rec->lba);
+                       *blocks = to_be32((uint32_t)rec->lba);
                }
                blocks_entry += record_len;
                tag_tbl_size -= record_len;

diff --git a/lwext4/ext4_mkfs.c b/lwext4/ext4_mkfs.c
index 2077832c853c5d6d39296f94fc5d69d77fad04c8..5712ef3bb94a68c7b70e2dbf01ec8f3b452c564d 100644 (file)
--- a/lwext4/ext4_mkfs.c
+++ b/lwext4/ext4_mkfs.c
@@ -105,12 +105,12 @@ static uint32_t compute_blocks_per_group(struct ext4_mkfs_info *info)
 
 static uint32_t compute_inodes(struct ext4_mkfs_info *info)
 {
-       return DIV_ROUND_UP(info->len, info->block_size) / 4;
+       return (uint32_t)DIV_ROUND_UP(info->len, info->block_size) / 4;
 }
 
 static uint32_t compute_inodes_per_group(struct ext4_mkfs_info *info)
 {
-       uint32_t blocks = DIV_ROUND_UP(info->len, info->block_size);
+       uint32_t blocks = (uint32_t)DIV_ROUND_UP(info->len, info->block_size);
        uint32_t block_groups = DIV_ROUND_UP(blocks, info->blocks_per_group);
        uint32_t inodes = DIV_ROUND_UP(info->inodes, block_groups);
        inodes = EXT4_ALIGN(inodes, (info->block_size / info->inode_size));
@@ -126,7 +126,8 @@ static uint32_t compute_inodes_per_group(struct ext4_mkfs_info *info)
 
 static uint32_t compute_journal_blocks(struct ext4_mkfs_info *info)
 {
-       uint32_t journal_blocks = DIV_ROUND_UP(info->len, info->block_size) / 64;
+       uint32_t journal_blocks = (uint32_t)DIV_ROUND_UP(info->len,
+                                                info->block_size) / 64;
        if (journal_blocks < 1024)
                journal_blocks = 1024;
        if (journal_blocks > 32768)
@@ -149,7 +150,7 @@ static int create_fs_aux_info(struct fs_aux_info *aux_info,
        aux_info->len_blocks = info->len / info->block_size;
        aux_info->inode_table_blocks = DIV_ROUND_UP(info->inodes_per_group *
                        info->inode_size, info->block_size);
-       aux_info->groups = DIV_ROUND_UP(aux_info->len_blocks -
+       aux_info->groups = (uint32_t)DIV_ROUND_UP(aux_info->len_blocks -
                        aux_info->first_data_block, info->blocks_per_group);
        aux_info->blocks_per_ind = info->block_size / sizeof(uint32_t);
        aux_info->blocks_per_dind =
@@ -297,7 +298,7 @@ static void fill_bgroups(struct fs_aux_info *aux_info,
 {
        uint32_t i;
 
-       uint64_t bg_free_blk = 0;
+       uint32_t bg_free_blk = 0;
        uint64_t sb_free_blk = 0;
 
        for (i = 0; i < aux_info->groups; i++) {

diff --git a/lwext4/ext4_super.c b/lwext4/ext4_super.c
index 09f8b5d9bf4493ca4b26412e04b91ef207195d0e..582d1fb0d1704c8e06a658bc39a85c0af6c88b9e 100644 (file)
--- a/lwext4/ext4_super.c
+++ b/lwext4/ext4_super.c
@@ -48,7 +48,7 @@ uint32_t ext4_block_group_cnt(struct ext4_sblock *s)
        uint64_t blocks_count = ext4_sb_get_blocks_cnt(s);
        uint32_t blocks_per_group = ext4_get32(s, blocks_per_group);
 
-       uint32_t block_groups_count = blocks_count / blocks_per_group;
+       uint32_t block_groups_count = (uint32_t)(blocks_count / blocks_per_group);
 
        if (blocks_count % blocks_per_group)
                block_groups_count++;
@@ -65,7 +65,7 @@ uint32_t ext4_blocks_in_group_cnt(struct ext4_sblock *s, uint32_t bgid)
        if (bgid < block_group_count - 1)
                return blocks_per_group;
 
-       return (total_blocks - ((block_group_count - 1) * blocks_per_group));
+       return (uint32_t)(total_blocks - ((block_group_count - 1) * blocks_per_group));
 }
 
 uint32_t ext4_inodes_in_group_cnt(struct ext4_sblock *s, uint32_t bgid)

diff --git a/lwext4/ext4_xattr.c b/lwext4/ext4_xattr.c
index 14baed8165ae358a927a87f884e287baf1c50037..54d457d43f083c6760d9f72f6a9ef9c558f90001 100644 (file)
--- a/lwext4/ext4_xattr.c
+++ b/lwext4/ext4_xattr.c
@@ -590,7 +590,7 @@ ext4_xattr_set_inode_entry(struct ext4_xattr_item *item,
                           struct ext4_xattr_ibody_header *ibody_header,
                           struct ext4_xattr_entry *entry, void *ibody_data_ptr)
 {
-       entry->e_name_len = to_le32(item->name_len);
+       entry->e_name_len = (uint8_t)item->name_len;
        entry->e_name_index = item->name_index;
        entry->e_value_offs =
            (char *)ibody_data_ptr - (char *)EXT4_XATTR_IFIRST(ibody_header);
@@ -603,7 +603,7 @@ static void ext4_xattr_set_block_entry(struct ext4_xattr_item *item,
                                       struct ext4_xattr_entry *block_entry,
                                       void *block_data_ptr)
 {
-       block_entry->e_name_len = to_le32(item->name_len);
+       block_entry->e_name_len = (uint8_t)item->name_len;
        block_entry->e_name_index = item->name_index;
        block_entry->e_value_offs =
            (char *)block_data_ptr - (char *)block_header;