2 files changed, 112 insertions, 8 deletions

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index e6634550cfc8..bb89fe727bb1 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -2667,6 +2667,22 @@ void ext4_get_inode_flags(struct ext4_inode_info *ei)
         if (flags & S_DIRSYNC)
                 ei->i_flags |= EXT4_DIRSYNC_FL;
 }
+static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
+                                        struct ext4_inode_info *ei)
+{
+        blkcnt_t i_blocks ;
+        struct super_block *sb = ei->vfs_inode.i_sb;
+
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                                EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
+                /* we are using combined 48 bit field */
+                i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
+                                        le32_to_cpu(raw_inode->i_blocks_lo);
+                return i_blocks;
+        } else {
+                return le32_to_cpu(raw_inode->i_blocks_lo);
+        }
+}
 
 void ext4_read_inode(struct inode * inode)
 {
@@ -2715,8 +2731,8 @@ void ext4_read_inode(struct inode * inode)
                  * recovery code: that's fine, we're about to complete
                  * the process of deleting those. */
         }
-        inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
         ei->i_flags = le32_to_cpu(raw_inode->i_flags);
+        inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
         ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
         if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
             cpu_to_le32(EXT4_OS_HURD)) {
@@ -2799,6 +2815,43 @@ bad_inode:
         return;
 }
 
+static int ext4_inode_blocks_set(handle_t *handle,
+                                struct ext4_inode *raw_inode,
+                                struct ext4_inode_info *ei)
+{
+        struct inode *inode = &(ei->vfs_inode);
+        u64 i_blocks = inode->i_blocks;
+        struct super_block *sb = inode->i_sb;
+        int err = 0;
+
+        if (i_blocks <= ~0U) {
+                /*
+                 * i_blocks can be represnted in a 32 bit variable
+                 * as multiple of 512 bytes
+                 */
+                raw_inode->i_blocks_lo   = cpu_to_le32((u32)i_blocks);
+                raw_inode->i_blocks_high = 0;
+        } else if (i_blocks <= 0xffffffffffffULL) {
+                /*
+                 * i_blocks can be represented in a 48 bit variable
+                 * as multiple of 512 bytes
+                 */
+                err = ext4_update_rocompat_feature(handle, sb,
+                                            EXT4_FEATURE_RO_COMPAT_HUGE_FILE);
+                if (err)
+                        goto  err_out;
+                /* i_block is stored in the split  48 bit fields */
+                raw_inode->i_blocks_lo   = cpu_to_le32((u32)i_blocks);
+                raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
+        } else {
+                ext4_error(sb, __FUNCTION__,
+                                "Wrong inode i_blocks count  %llu\n",
+                                (unsigned long long)inode->i_blocks);
+        }
+err_out:
+        return err;
+}
+
 /*
  * Post the struct inode info into an on-disk inode location in the
  * buffer-cache.  This gobbles the caller's reference to the
@@ -2853,7 +2906,8 @@ static int ext4_do_update_inode(handle_t *handle,
         EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
         EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
 
-        raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
+        if (ext4_inode_blocks_set(handle, raw_inode, ei))
+                goto out_brelse;
         raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
         raw_inode->i_flags = cpu_to_le32(ei->i_flags);
         if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 7be27dbe76bf..2b9dc96ec43e 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -1603,17 +1603,50 @@ static void ext4_orphan_cleanup (struct super_block * sb,
 
 /*
  * Maximal file size.  There is a direct, and {,double-,triple-}indirect
- * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
- * We need to be 1 filesystem block less than the 2^32 sector limit.
+ * block limit, and also a limit of (2^48 - 1) 512-byte sectors in i_blocks.
+ * We need to be 1 filesystem block less than the 2^48 sector limit.
  */
 static loff_t ext4_max_size(int bits)
 {
         loff_t res = EXT4_NDIR_BLOCKS;
-        /* This constant is calculated to be the largest file size for a
-         * dense, 4k-blocksize file such that the total number of
+        int meta_blocks;
+        loff_t upper_limit;
+        /* This is calculated to be the largest file size for a
+         * dense, file such that the total number of
          * sectors in the file, including data and all indirect blocks,
-         * does not exceed 2^32. */
-        const loff_t upper_limit = 0x1ff7fffd000LL;
+         * does not exceed 2^48 -1
+         * __u32 i_blocks_lo and _u16 i_blocks_high representing the
+         * total number of  512 bytes blocks of the file
+         */
+
+        if (sizeof(blkcnt_t) < sizeof(u64)) {
+                /*
+                 * CONFIG_LSF is not enabled implies the inode
+                 * i_block represent total blocks in 512 bytes
+                 * 32 == size of vfs inode i_blocks * 8
+                 */
+                upper_limit = (1LL << 32) - 1;
+
+                /* total blocks in file system block size */
+                upper_limit >>= (bits - 9);
+
+        } else {
+                /* We use 48 bit ext4_inode i_blocks */
+                upper_limit = (1LL << 48) - 1;
+
+                /* total blocks in file system block size */
+                upper_limit >>= (bits - 9);
+        }
+
+        /* indirect blocks */
+        meta_blocks = 1;
+        /* double indirect blocks */
+        meta_blocks += 1 + (1LL << (bits-2));
+        /* tripple indirect blocks */
+        meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
+
+        upper_limit -= meta_blocks;
+        upper_limit <<= bits;
 
         res += 1LL << (bits-2);
         res += 1LL << (2*(bits-2));
@@ -1621,6 +1654,10 @@ static loff_t ext4_max_size(int bits)
         res <<= bits;
         if (res > upper_limit)
                 res = upper_limit;
+
+        if (res > MAX_LFS_FILESIZE)
+                res = MAX_LFS_FILESIZE;
+
         return res;
 }
 
@@ -1789,6 +1826,19 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
                        sb->s_id, le32_to_cpu(features));
                 goto failed_mount;
         }
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
+                /*
+                 * Large file size enabled file system can only be
+                 * mount if kernel is build with CONFIG_LSF
+                 */
+                if (sizeof(root->i_blocks) < sizeof(u64) &&
+                                !(sb->s_flags & MS_RDONLY)) {
+                        printk(KERN_ERR "EXT4-fs: %s: Filesystem with huge "
+                                        "files cannot be mounted read-write "
+                                        "without CONFIG_LSF.\n", sb->s_id);
+                        goto failed_mount;
+                }
+        }
         blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
 
         if (blocksize < EXT4_MIN_BLOCK_SIZE ||