The following patches have been in the -mm tree for a while, and I

plan to push them to Linus when the 2.6.25 merge window opens.  With

this patch series, it is expected that ext4 format should be settling

down.  We still have delayed allocation and online defrag which aren't

quite ready to merge, but those shouldn't affect the on-disk format.
I don't expect any other on-disk format changes to show up after this

point, but I've been wrong before....  any such changes would have to

have a Really Good Reason, though.  (No, Abhishek Rai's changes

wouldn't count as an on-disk change, since they change layout choices,

but not anything that e2fsck would actually care about.  We may try

merging those into ext4 and see how they play out in the -mm tree;

we'll see.)
						- Ted
P.S.  Yes, the currently released e2fsprogs won't support all of these

format changes yet; again ext4, shouldn't be deployed to production

systems yet, although we do salute those who are willing to be guinea

pigs and play with this code!  Never fear, I'll be working to get

e2fsprogs caught up Real Soon Now.
Adrian Bunk (1):

      ext4/super.c: fix #ifdef's (CONFIG_EXT4_* -> CONFIG_EXT4DEV_*)
Alex Tomas (2):

      ext4: Add new functions for searching extent tree

      ext4: Add multi block allocator for ext4
Aneesh Kumar K.V (23):

      ext4: Introduce ext4_lblk_t

      ext4: Introduce ext4_update_*_feature

      ext4:  Fix sparse warnings.

      ext4: Rename i_file_acl to i_file_acl_lo

      ext4: Rename i_dir_acl to i_size_high

      ext4: Add support for 48 bit inode i_blocks.

      ext4: Support large files

      ext2: Fix the max file size for ext2 file system.

      ext3: Fix the max file size for ext3 file system.

      ext4: Return after ext4_error in case of failures

      ext4: Change the default behaviour on error

      Add buffer head related helper functions

      ext4: add block bitmap validation

      ext4: Check for the correct error return from

      ext4: Make ext4_get_blocks_w...
[ message continues ]

The log is pretty messy, any chance you could reshuffle the gazillions

of fixup patches into the few feature patches to give a proper readable

history in git?
--

From: Takashi Sato <sho@tnes.nec.co.jp>
This patch set supports large block size(>4k, <=64k) in ext4,

just enlarging the block size limit. But it is NOT possible to have 64kB

blocksize on ext4 without some changes to the directory handling

code.  The reason is that an empty 64kB directory block would have a

rec_len == (__u16)2^16 == 0, and this would cause an error to be hit in

the filesystem.  The proposed solution is treat 64k rec_len

with a an impossible value like rec_len = 0xffff to handle this.
The Patch-set consists of the following 2 patches.

  [1/2]  ext4: enlarge blocksize

         - Allow blocksize up to pagesize
  [2/2]  ext4: fix rec_len overflow

         - prevent rec_len from overflow with 64KB blocksize
Now on 64k page ppc64 box runs with this patch set we could create a 64k

block size ext4dev, and able to handle empty directory block.
Signed-off-by: Takashi Sato <sho@tnes.nec.co.jp>

Signed-off-by: Mingming Cao <cmm@us.ibm.com>

---

 fs/ext4/super.c         |    5 +++++

 include/linux/ext4_fs.h |    4 ++--

 2 files changed, 7 insertions(+), 2 deletions(-)
diff --git a/fs/ext4/super.c b/fs/ext4/super.c

index 1ca0f54..ab7010d 100644

--- a/fs/ext4/super.c

+++ b/fs/ext4/super.c

@@ -1624,6 +1624,11 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)

 		goto out_fail;

 	}
+	if (!sb_set_blocksize(sb, blocksize)) {

+		printk(KERN_ERR "EXT4-fs: bad blocksize %d.\n", blocksize);

+		goto out_fail;

+	}

+

 	/*

 	 * The ext4 superblock will not be buffer aligned for other than 1kB

 	 * block sizes.  We need to calculate the offset from buffer start.

diff --git a/include/linux/ext4_fs.h b/include/linux/ext4_fs.h

index 97dd409..dfe4487 100644

--- a/include/linux/ext4_fs.h

+++ b/include/linux/ext4_fs.h

@@ -73,8 +73,8 @@

  * Macro-instructions used to manage several block sizes

  */

 #define EXT4_MIN_BLOCK_SIZE		1024

-#define	EXT4_MAX_BLOCK_SIZE		4096

-#define EXT4_MIN_BLOCK_LOG_SIZE		  10

+#define	EXT4_MA...
[ message continues ]

From: Jan Kara <jack@suse.cz>
With 64KB blocksize, a directory entry can have size 64KB which does not fit

into 16 bits we have for entry lenght. So we store 0xffff instead and convert

value when read from / written to disk. The patch also converts some places

to use ext4_next_entry() when we are changing them anyway.
Signed-off-by: Jan Kara <jack@suse.cz>

Signed-off-by: Mingming Cao <cmm@us.ibm.com>

---

 fs/ext4/dir.c           |   12 ++++----

 fs/ext4/namei.c         |   77 ++++++++++++++++++++++------------------------

 include/linux/ext4_fs.h |   20 ++++++++++++

 3 files changed, 63 insertions(+), 46 deletions(-)
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c

index f612bef..145a9c0 100644

--- a/fs/ext4/dir.c

+++ b/fs/ext4/dir.c

@@ -67,7 +67,7 @@ int ext4_check_dir_entry (const char * function, struct inode * dir,

 			  unsigned long offset)

 {

 	const char * error_msg = NULL;

-	const int rlen = le16_to_cpu(de->rec_len);

+	const int rlen = ext4_rec_len_from_disk(de->rec_len);
 	if (rlen < EXT4_DIR_REC_LEN(1))

 		error_msg = "rec_len is smaller than minimal";

@@ -172,10 +172,10 @@ revalidate:

 				 * least that it is non-zero.  A

 				 * failure will be detected in the

 				 * dirent test below. */

-				if (le16_to_cpu(de->rec_len) <

-						EXT4_DIR_REC_LEN(1))

+				if (ext4_rec_len_from_disk(de->rec_len)

+						< EXT4_DIR_REC_LEN(1))

 					break;

-				i += le16_to_cpu(de->rec_len);

+				i += ext4_rec_len_from_disk(de->rec_len);

 			}

 			offset = i;

 			filp->f_pos = (filp->f_pos & ~(sb->s_blocksize - 1))

@@ -197,7 +197,7 @@ revalidate:

 				ret = stored;

 				goto out;

 			}

-			offset += le16_to_cpu(de->rec_len);

+			offset += ext4_rec_len_from_disk(de->rec_len);

 			if (le32_to_cpu(de->inode)) {

 				/* We might block in the next section

 				 * if the data destination is

@@ -219,7 +219,7 @@ revalidate:

 					goto revalidate;

 				stored ++;

 			}

-			filp->f_pos += le16_to_cpu(de-&g...
[ message continues ]

From: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
This patch adds a new data type ext4_lblk_t to represent

the logical file blocks.
This is the preparatory patch to support large files in ext4

The follow up patch with convert the ext4_inode i_blocks to

represent the number of blocks in file system block size. This

changes makes it possible to have a block number 2**32 -1 which

will result in overflow if the block number is represented by

signed long. This patch convert all the block number to type

ext4_lblk_t which is typedef to __u32
Also remove dead code ext4_ext_walk_space
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>

Signed-off-by: Mingming Cao <cmm@us.ibm.com>

Signed-off-by: Eric Sandeen <sandeen@redhat.com>

---

 fs/ext4/dir.c                   |    2 +-

 fs/ext4/extents.c               |  218 ++++++++++++---------------------------

 fs/ext4/inode.c                 |   34 ++++---

 fs/ext4/namei.c                 |   54 ++++++-----

 fs/ext4/super.c                 |    4 +-

 include/linux/ext4_fs.h         |   29 ++++--

 include/linux/ext4_fs_extents.h |   19 +---

 include/linux/ext4_fs_i.h       |    9 +-

 8 files changed, 143 insertions(+), 226 deletions(-)
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c

index 145a9c0..33888bb 100644

--- a/fs/ext4/dir.c

+++ b/fs/ext4/dir.c

@@ -124,7 +124,7 @@ static int ext4_readdir(struct file * filp,

 	offset = filp->f_pos & (sb->s_blocksize - 1);
 	while (!error && !stored && filp->f_pos < inode->i_size) {

-		unsigned long blk = filp->f_pos >> EXT4_BLOCK_SIZE_BITS(sb);

+		ext4_lblk_t blk = filp->f_pos >> EXT4_BLOCK_SIZE_BITS(sb);

 		struct buffer_head map_bh;

 		struct buffer_head *bh = NULL;
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c

index 8528774..19d8059 100644

--- a/fs/ext4/extents.c

+++ b/fs/ext4/extents.c

@@ -144,7 +144,7 @@ static int ext4_ext_dirty(handle_t *handle, struct inode *inode,
 static ext4_...
[ message continues ]

From: Eric Sandeen <sandeen@redhat.com>
There are many casts in extents.c which are not needed,

as the variables are already the type of the cast, or

are being promoted for no particular reason in printk's.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>

Signed-off-by: Mingming Cao <cmm@us.ibm.com>

---

 fs/ext4/extents.c |   49 ++++++++++++++++++++++---------------------------

 1 files changed, 22 insertions(+), 27 deletions(-)
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c

index 19d8059..6853722 100644

--- a/fs/ext4/extents.c

+++ b/fs/ext4/extents.c

@@ -374,7 +374,7 @@ ext4_ext_binsearch_idx(struct inode *inode,

 	struct ext4_extent_idx *r, *l, *m;
-	ext_debug("binsearch for %lu(idx):  ", (unsigned long)block);

+	ext_debug("binsearch for %u(idx):  ", block);
 	l = EXT_FIRST_INDEX(eh) + 1;

 	r = EXT_LAST_INDEX(eh);

@@ -440,7 +440,7 @@ ext4_ext_binsearch(struct inode *inode,

 		return;

 	}
-	ext_debug("binsearch for %lu:  ", (unsigned long)block);

+	ext_debug("binsearch for %u:  ", block);
 	l = EXT_FIRST_EXTENT(eh) + 1;

 	r = EXT_LAST_EXTENT(eh);

@@ -766,7 +766,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,

 	while (k--) {

 		oldblock = newblock;

 		newblock = ablocks[--a];

-		bh = sb_getblk(inode->i_sb, (ext4_fsblk_t)newblock);

+		bh = sb_getblk(inode->i_sb, newblock);

 		if (!bh) {

 			err = -EIO;

 			goto cleanup;

@@ -786,9 +786,8 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,

 		fidx->ei_block = border;

 		ext4_idx_store_pblock(fidx, oldblock);
-		ext_debug("int.index at %d (block %llu): %lu -> %llu\n", i,

-				newblock, (unsigned long) le32_to_cpu(border),

-				oldblock);

+		ext_debug("int.index at %d (block %llu): %u -> %llu\n",

+				i, newblock, le32_to_cpu(border), oldblock);

 		/* copy indexes */

 		m = 0;

 		path[i].p_idx++;

@@ -1476,10 +1475,10 @@ ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,

 	} else if (block < le32_to...
[ message continues ]

From: Avantika Mathur <mathur@us.ibm.com>
In many places variables for block group are of type int, which limits the

maximum number of block groups to 2^31.  Each block group can have up to

2^15 blocks, with a 4K block size,  and the max filesystem size is limited to

2^31 * (2^15 * 2^12) = 2^58  -- or 256 PB
This patch introduces a new type ext4_group_t, of type unsigned long, to

represent block group numbers in ext4.

All occurrences of block group variables are converted to type ext4_group_t.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>

---

 fs/ext4/balloc.c           |   69 +++++++++++++++++++++-----------------------

 fs/ext4/group.h            |    8 +++--

 fs/ext4/ialloc.c           |   46 +++++++++++++++--------------

 fs/ext4/inode.c            |    5 ++-

 fs/ext4/resize.c           |   12 ++++----

 fs/ext4/super.c            |   20 ++++++-------

 include/linux/ext4_fs.h    |   11 ++++---

 include/linux/ext4_fs_i.h  |    5 ++-

 include/linux/ext4_fs_sb.h |    2 +-

 9 files changed, 91 insertions(+), 87 deletions(-)
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c

index 71ee95e..9568a57 100644

--- a/fs/ext4/balloc.c

+++ b/fs/ext4/balloc.c

@@ -29,7 +29,7 @@

  * Calculate the block group number and offset, given a block number

  */

 void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,

-		unsigned long *blockgrpp, ext4_grpblk_t *offsetp)

+		ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp)

 {

 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;

 	ext4_grpblk_t offset;

@@ -46,7 +46,7 @@ void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,

 /* Initializes an uninitialized block bitmap if given, and returns the

  * number of blocks free in the group. */

 unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,

-				int block_group, struct ext4_group_desc *gdp)

+		 ext4_group_t block_group, struct ext4_group_desc *gdp)

 {

 	unsigned long start;

 	int bit, bit_max;

@@ -60,...
[ message continues ]

From: Avantika Mathur <mathur@us.ibm.com>
This patch fixes various places where the group number is set to a negative

value.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>

Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

---

 fs/ext4/ialloc.c |  101 ++++++++++++++++++++++++++++-------------------------

 1 files changed, 53 insertions(+), 48 deletions(-)
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c

index 64dea86..7b5cfa6 100644

--- a/fs/ext4/ialloc.c

+++ b/fs/ext4/ialloc.c

@@ -260,12 +260,14 @@ error_return:

  * For other inodes, search forward from the parent directory\'s block

  * group to find a free inode.

  */

-static ext4_group_t find_group_dir(struct super_block *sb, struct inode *parent)

+static int find_group_dir(struct super_block *sb, struct inode *parent,

+				ext4_group_t *best_group)

 {

 	ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;

 	unsigned int freei, avefreei;

 	struct ext4_group_desc *desc, *best_desc = NULL;

-	ext4_group_t group, best_group = -1;

+	ext4_group_t group;

+	int ret = -1;
 	freei = percpu_counter_read_positive(&EXT4_SB(sb)->s_freeinodes_counter);

 	avefreei = freei / ngroups;

@@ -279,11 +281,12 @@ static ext4_group_t find_group_dir(struct super_block *sb, struct inode *parent)

 		if (!best_desc ||

 		    (le16_to_cpu(desc->bg_free_blocks_count) >

 		     le16_to_cpu(best_desc->bg_free_blocks_count))) {

-			best_group = group;

+			*best_group = group;

 			best_desc = desc;

+			ret = 0;

 		}

 	}

-	return best_group;

+	return ret;

 }
 /*

@@ -314,8 +317,8 @@ static ext4_group_t find_group_dir(struct super_block *sb, struct inode *parent)

 #define INODE_COST 64

 #define BLOCK_COST 256
-static ext4_group_t find_group_orlov(struct super_block *sb,

-				      struct inode *parent)

+static int find_group_orlov(struct super_block *sb, struct inode *parent,

+				ext4_group_t *group)

 {

 	ext4_group_t parent_group = EXT4_I(parent)->i_block_group;

 	struct ext4_sb_info *sbi = EX...
[ message continues ]