fs: fat: get_contents() always returns -1 for errors

[oweals/u-boot.git] / fs / ext4 / ext4_common.c

diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c
index 29308e3b44741b8ee484158223df5976d428980d..5bf78b530a989108e9298f4c374f7794de10a9a5 100644 (file)
--- a/fs/ext4/ext4_common.c
+++ b/fs/ext4/ext4_common.c
@@ -190,7 +190,7 @@ uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n)
        return res;
 }
 
-void put_ext4(uint64_t off, void *buf, uint32_t size)
+void put_ext4(uint64_t off, const void *buf, uint32_t size)
 {
        uint64_t startblock;
        uint64_t remainder;
@@ -570,7 +570,7 @@ restart_read:
                                g_parent_inode->size = cpu_to_le32(new_size);
 
                                new_blockcnt = le32_to_cpu(g_parent_inode->blockcnt);
-                               new_blockcnt += fs->sect_perblk;
+                               new_blockcnt += fs->blksz >> LOG2_SECTOR_SIZE;
                                g_parent_inode->blockcnt = cpu_to_le32(new_blockcnt);
 
                                if (ext4fs_put_metadata
@@ -608,7 +608,7 @@ restart_read:
                dir->direntlen = cpu_to_le16(fs->blksz - totalbytes);
 
        dir->namelen = strlen(filename);
-       dir->filetype = FILETYPE_REG;   /* regular file */
+       dir->filetype = file_type;
        temp_dir = (char *)dir;
        temp_dir = temp_dir + sizeof(struct ext2_dirent);
        memcpy(temp_dir, filename, strlen(filename));
@@ -1547,8 +1547,12 @@ static struct ext4_extent_header *ext4fs_get_extent_block
                                break;
                } while (fileblock >= le32_to_cpu(index[i].ei_block));
 
-               if (--i < 0)
-                       return NULL;
+               /*
+                * If first logical block number is higher than requested fileblock,
+                * it is a sparse file. This is handled on upper layer.
+                */
+               if (i > 0)
+                       i--;
 
                block = le16_to_cpu(index[i].ei_leaf_hi);
                block = (block << 32) + le32_to_cpu(index[i].ei_leaf_lo);
@@ -1567,8 +1571,12 @@ static int ext4fs_blockgroup
        int log2blksz = get_fs()->dev_desc->log2blksz;
        int desc_size = get_fs()->gdsize;
 
+       if (desc_size == 0)
+               return 0;
        desc_per_blk = EXT2_BLOCK_SIZE(data) / desc_size;
 
+       if (desc_per_blk == 0)
+               return 0;
        blkno = le32_to_cpu(data->sblock.first_data_block) + 1 +
                        group / desc_per_blk;
        blkoff = (group % desc_per_blk) * desc_size;
@@ -1583,7 +1591,7 @@ static int ext4fs_blockgroup
 
 int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode)
 {
-       struct ext2_block_group blkgrp;
+       struct ext2_block_group *blkgrp;
        struct ext2_sblock *sblock = &data->sblock;
        struct ext_filesystem *fs = get_fs();
        int log2blksz = get_fs()->dev_desc->log2blksz;
@@ -1591,17 +1599,36 @@ int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode)
        long int blkno;
        unsigned int blkoff;
 
+       /* Allocate blkgrp based on gdsize (for 64-bit support). */
+       blkgrp = zalloc(get_fs()->gdsize);
+       if (!blkgrp)
+               return 0;
+
        /* It is easier to calculate if the first inode is 0. */
        ino--;
+       if ( le32_to_cpu(sblock->inodes_per_group) == 0 || fs->inodesz == 0) {
+               free(blkgrp);
+               return 0;
+       }
        status = ext4fs_blockgroup(data, ino / le32_to_cpu
-                                  (sblock->inodes_per_group), &blkgrp);
-       if (status == 0)
+                                  (sblock->inodes_per_group), blkgrp);
+       if (status == 0) {
+               free(blkgrp);
                return 0;
+       }
 
        inodes_per_block = EXT2_BLOCK_SIZE(data) / fs->inodesz;
-       blkno = ext4fs_bg_get_inode_table_id(&blkgrp, fs) +
+       if ( inodes_per_block == 0 ) {
+               free(blkgrp);
+               return 0;
+       }
+       blkno = ext4fs_bg_get_inode_table_id(blkgrp, fs) +
            (ino % le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
        blkoff = (ino % inodes_per_block) * fs->inodesz;
+
+       /* Free blkgrp as it is no longer required. */
+       free(blkgrp);
+
        /* Read the inode. */
        status = ext4fs_devread((lbaint_t)blkno << (LOG2_BLOCK_SIZE(data) -
                                log2blksz), blkoff,