[PATCH] ext3_fsblk_t: filesystem, group blocks and bug fixes

Some of the in-kernel ext3 block variable type are treated as signed 4 bytes
int type, thus limited ext3 filesystem to 8TB (4kblock size based).  While
trying to fix them, it seems quite confusing in the ext3 code where some
blocks are filesystem-wide blocks, some are group relative offsets that need
to be signed value (as -1 has special meaning).  So it seem saner to define
two types of physical blocks: one is filesystem wide blocks, another is
group-relative blocks.  The following patches clarify these two types of
blocks in the ext3 code, and fix the type bugs which limit current 32 bit ext3
filesystem limit to 8TB.

With this series of patches and the percpu counter data type changes in the mm
tree, we are able to extend exts filesystem limit to 16TB.

This work is also a pre-request for the recent >32 bit ext3 work, and makes
the kernel to able to address 48 bit ext3 block a lot easier: Simply redefine
ext3_fsblk_t from unsigned long to sector_t and redefine the format string for
ext3 filesystem block corresponding.

Two RFC with a series patches have been posted to ext2-devel list and have
been reviewed and discussed:
http://marc.theaimsgroup.com/?l=ext2-devel&m=114722190816690&w=2

http://marc.theaimsgroup.com/?l=ext2-devel&m=114784919525942&w=2

Patches are tested on both 32 bit machine and 64 bit machine, <8TB ext3 and
>8TB ext3 filesystem(with the latest to be released e2fsprogs-1.39).  Tests
includes overnight fsx, tiobench, dbench and fsstress.

This patch:

Defines ext3_fsblk_t and ext3_grpblk_t, and the printk format string for
filesystem wide blocks.

This patch classifies all block group relative blocks, and ext3_fsblk_t blocks
occurs in the same function where used to be confusing before.  Also include
kernel bug fixes for filesystem wide in-kernel block variables.  There are
some fileystem wide blocks are treated as int/unsigned int type in the kernel
currently, especially in ext3 block allocation and reservation code.  This
patch fixed those bugs by converting those variables to ext3_fsblk_t(unsigned
long) type.

Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 14 insertions, 13 deletions

diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index e8d60bf6b7df..1ba515de5a75 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -225,7 +225,7 @@ ext3_xattr_block_get(struct inode *inode, int name_index, const char *name,
         error = -ENODATA;
         if (!EXT3_I(inode)->i_file_acl)
                 goto cleanup;
-        ea_idebug(inode, "reading block %d", EXT3_I(inode)->i_file_acl);
+        ea_idebug(inode, "reading block %u", EXT3_I(inode)->i_file_acl);
         bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl);
         if (!bh)
                 goto cleanup;
@@ -233,7 +233,7 @@ ext3_xattr_block_get(struct inode *inode, int name_index, const char *name,
                 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
         if (ext3_xattr_check_block(bh)) {
 bad_block:      ext3_error(inode->i_sb, __FUNCTION__,
-                           "inode %ld: bad block %d", inode->i_ino,
+                           "inode %ld: bad block %u", inode->i_ino,
                            EXT3_I(inode)->i_file_acl);
                 error = -EIO;
                 goto cleanup;
@@ -366,7 +366,7 @@ ext3_xattr_block_list(struct inode *inode, char *buffer, size_t buffer_size)
         error = 0;
         if (!EXT3_I(inode)->i_file_acl)
                 goto cleanup;
-        ea_idebug(inode, "reading block %d", EXT3_I(inode)->i_file_acl);
+        ea_idebug(inode, "reading block %u", EXT3_I(inode)->i_file_acl);
         bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl);
         error = -EIO;
         if (!bh)
@@ -375,7 +375,7 @@ ext3_xattr_block_list(struct inode *inode, char *buffer, size_t buffer_size)
                 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
         if (ext3_xattr_check_block(bh)) {
                 ext3_error(inode->i_sb, __FUNCTION__,
-                           "inode %ld: bad block %d", inode->i_ino,
+                           "inode %ld: bad block %u", inode->i_ino,
                            EXT3_I(inode)->i_file_acl);
                 error = -EIO;
                 goto cleanup;
@@ -647,7 +647,7 @@ ext3_xattr_block_find(struct inode *inode, struct ext3_xattr_info *i,
                         le32_to_cpu(BHDR(bs->bh)->h_refcount));
                 if (ext3_xattr_check_block(bs->bh)) {
                         ext3_error(sb, __FUNCTION__,
-                                "inode %ld: bad block %d", inode->i_ino,
+                                "inode %ld: bad block %u", inode->i_ino,
                                 EXT3_I(inode)->i_file_acl);
                         error = -EIO;
                         goto cleanup;
@@ -792,11 +792,12 @@ inserted:
                         get_bh(new_bh);
                 } else {
                         /* We need to allocate a new block */
-                        int goal = le32_to_cpu(
+                        ext3_fsblk_t goal = le32_to_cpu(
                                         EXT3_SB(sb)->s_es->s_first_data_block) +
-                                EXT3_I(inode)->i_block_group *
+                                (ext3_fsblk_t)EXT3_I(inode)->i_block_group *
                                 EXT3_BLOCKS_PER_GROUP(sb);
-                        int block = ext3_new_block(handle, inode, goal, &error);
+                        ext3_fsblk_t block = ext3_new_block(handle, inode,
+                                                        goal, &error);
                         if (error)
                                 goto cleanup;
                         ea_idebug(inode, "creating block %d", block);
@@ -847,7 +848,7 @@ cleanup_dquot:
 
 bad_block:
         ext3_error(inode->i_sb, __FUNCTION__,
-                   "inode %ld: bad block %d", inode->i_ino,
+                   "inode %ld: bad block %u", inode->i_ino,
                    EXT3_I(inode)->i_file_acl);
         goto cleanup;
 
@@ -1076,14 +1077,14 @@ ext3_xattr_delete_inode(handle_t *handle, struct inode *inode)
         bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl);
         if (!bh) {
                 ext3_error(inode->i_sb, __FUNCTION__,
-                        "inode %ld: block %d read error", inode->i_ino,
+                        "inode %ld: block %u read error", inode->i_ino,
                         EXT3_I(inode)->i_file_acl);
                 goto cleanup;
         }
         if (BHDR(bh)->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC) ||
             BHDR(bh)->h_blocks != cpu_to_le32(1)) {
                 ext3_error(inode->i_sb, __FUNCTION__,
-                        "inode %ld: bad block %d", inode->i_ino,
+                        "inode %ld: bad block %u", inode->i_ino,
                         EXT3_I(inode)->i_file_acl);
                 goto cleanup;
         }
@@ -1210,11 +1211,11 @@ again:
                 bh = sb_bread(inode->i_sb, ce->e_block);
                 if (!bh) {
                         ext3_error(inode->i_sb, __FUNCTION__,
-                                "inode %ld: block %ld read error",
+                                "inode %ld: block %lu read error",
                                 inode->i_ino, (unsigned long) ce->e_block);
                 } else if (le32_to_cpu(BHDR(bh)->h_refcount) >=
                                 EXT3_XATTR_REFCOUNT_MAX) {
-                        ea_idebug(inode, "block %ld refcount %d>=%d",
+                        ea_idebug(inode, "block %lu refcount %d>=%d",
                                   (unsigned long) ce->e_block,
                                   le32_to_cpu(BHDR(bh)->h_refcount),
                                           EXT3_XATTR_REFCOUNT_MAX);