X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fkernel_patches%2Fpatches%2Fext3-extents-2.4.21-suse2.patch;h=34a0b9dbf0070dc1af66f27a9a5ad4dd7fe5d2b1;hb=9e1de69f7729392aea24c8bfc22d0220a0eeeedb;hp=786ab5c1bcabd7c1e313329ab619f0d1a86ce358;hpb=053d78f9ca3337bb62802c7c19d78f556fb39ac5;p=fs%2Flustre-release.git diff --git a/lustre/kernel_patches/patches/ext3-extents-2.4.21-suse2.patch b/lustre/kernel_patches/patches/ext3-extents-2.4.21-suse2.patch index 786ab5c..34a0b9d 100644 --- a/lustre/kernel_patches/patches/ext3-extents-2.4.21-suse2.patch +++ b/lustre/kernel_patches/patches/ext3-extents-2.4.21-suse2.patch @@ -1,10 +1,11 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c =================================================================== --- linux-2.4.21-suse2.orig/fs/ext3/extents.c 2003-01-30 13:24:37.000000000 +0300 -+++ linux-2.4.21-suse2/fs/ext3/extents.c 2004-02-05 20:50:31.000000000 +0300 -@@ -0,0 +1,2344 @@ ++++ linux-2.4.21-suse2/fs/ext3/extents.c 2004-11-03 00:34:45.404241880 +0300 +@@ -0,0 +1,2315 @@ +/* -+ * Copyright (C) 2003 Alex Tomas ++ * Copyright(c) 2003, 2004, 2005, Cluster File Systems, Inc, info@clusterfs.com ++ * Written by Alex Tomas + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as @@ -38,16 +39,37 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +#include +#include +#include ++#include +#include +#include +#include +#include +#include +#include -+#include +#include +#include + ++ ++static inline int ext3_ext_check_header(struct ext3_extent_header *eh) ++{ ++ if (eh->eh_magic != EXT3_EXT_MAGIC) { ++ printk(KERN_ERR "EXT3-fs: invalid magic = 0x%x\n", ++ (unsigned)eh->eh_magic); ++ return -EIO; ++ } ++ if (eh->eh_max == 0) { ++ printk(KERN_ERR "EXT3-fs: invalid eh_max = %u\n", ++ (unsigned)eh->eh_max); ++ return -EIO; ++ } ++ if (eh->eh_entries > eh->eh_max) { ++ printk(KERN_ERR "EXT3-fs: invalid eh_entries = %u\n", ++ (unsigned)eh->eh_entries); ++ return -EIO; ++ } ++ return 0; ++} ++ +static handle_t *ext3_ext_journal_restart(handle_t *handle, int needed) +{ + int err; @@ -64,8 +86,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +static int inline +ext3_ext_get_access_for_root(handle_t *h, struct ext3_extents_tree *tree) +{ -+ if (tree->get_write_access) -+ return tree->get_write_access(h,tree->buffer); ++ if (tree->ops->get_write_access) ++ return tree->ops->get_write_access(h,tree->buffer); + else + return 0; +} @@ -73,8 +95,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +static int inline +ext3_ext_mark_root_dirty(handle_t *h, struct ext3_extents_tree *tree) +{ -+ if (tree->mark_buffer_dirty) -+ return tree->mark_buffer_dirty(h,tree->buffer); ++ if (tree->ops->mark_buffer_dirty) ++ return tree->ops->mark_buffer_dirty(h,tree->buffer); + else + return 0; +} @@ -85,8 +107,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * - ENOMEM + */ +static int ext3_ext_get_access(handle_t *handle, -+ struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path) ++ struct ext3_extents_tree *tree, ++ struct ext3_ext_path *path) +{ + int err; + @@ -107,7 +129,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * - EIO + */ +static int ext3_ext_dirty(handle_t *handle, struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path) ++ struct ext3_ext_path *path) +{ + int err; + if (path->p_bh) { @@ -122,15 +144,15 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + +static int inline +ext3_ext_new_block(handle_t *handle, struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, struct ext3_extent *ex, -+ int *err) ++ struct ext3_ext_path *path, struct ext3_extent *ex, ++ int *err) +{ + int goal, depth, newblock; + struct inode *inode; + + EXT_ASSERT(tree); -+ if (tree->new_block) -+ return tree->new_block(handle, tree, path, ex, err); ++ if (tree->ops->new_block) ++ return tree->ops->new_block(handle, tree, path, ex, err); + + inode = tree->inode; + depth = EXT_DEPTH(tree); @@ -142,22 +164,24 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + unsigned long colour; + + bg_start = (ei->i_block_group * -+ EXT3_BLOCKS_PER_GROUP(inode->i_sb)) + ++ EXT3_BLOCKS_PER_GROUP(inode->i_sb)) + + le32_to_cpu(EXT3_SB(inode->i_sb)->s_es->s_first_data_block); + colour = (current->pid % 16) * + (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16); + goal = bg_start + colour; + } + ++ lock_kernel(); + newblock = ext3_new_block(handle, inode, goal, 0, 0, err); ++ unlock_kernel(); + return newblock; +} + +static inline void ext3_ext_tree_changed(struct ext3_extents_tree *tree) +{ -+ struct ext3_extent_header *neh; -+ neh = EXT_ROOT_HDR(tree); -+ neh->e_generation++; ++ struct ext3_extent_header *neh = EXT_ROOT_HDR(tree); ++ neh->eh_generation = ((EXT_FLAGS(neh) & ~EXT_FLAGS_CLR_UNKNOWN) << 24) | ++ (EXT_HDR_GEN(neh) + 1); +} + +static inline int ext3_ext_space_block(struct ext3_extents_tree *tree) @@ -165,8 +189,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + int size; + + size = (tree->inode->i_sb->s_blocksize - -+ sizeof(struct ext3_extent_header)) -+ / sizeof(struct ext3_extent); ++ sizeof(struct ext3_extent_header)) / ++ sizeof(struct ext3_extent); +#ifdef AGRESSIVE_TEST + size = 6; +#endif @@ -178,8 +202,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + int size; + + size = (tree->inode->i_sb->s_blocksize - -+ sizeof(struct ext3_extent_header)) -+ / sizeof(struct ext3_extent_idx); ++ sizeof(struct ext3_extent_header)) / ++ sizeof(struct ext3_extent_idx); +#ifdef AGRESSIVE_TEST + size = 5; +#endif @@ -190,8 +214,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +{ + int size; + -+ size = (tree->buffer_len - sizeof(struct ext3_extent_header)) -+ / sizeof(struct ext3_extent); ++ size = (tree->buffer_len - sizeof(struct ext3_extent_header)) / ++ sizeof(struct ext3_extent); +#ifdef AGRESSIVE_TEST + size = 3; +#endif @@ -202,9 +226,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +{ + int size; + -+ size = (tree->buffer_len - -+ sizeof(struct ext3_extent_header)) -+ / sizeof(struct ext3_extent_idx); ++ size = (tree->buffer_len - sizeof(struct ext3_extent_header)) / ++ sizeof(struct ext3_extent_idx); +#ifdef AGRESSIVE_TEST + size = 4; +#endif @@ -212,7 +235,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +} + +static void ext3_ext_show_path(struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path) ++ struct ext3_ext_path *path) +{ +#ifdef EXT_DEBUG + int k, l = path->p_depth; @@ -220,13 +243,13 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + ext_debug(tree, "path:"); + for (k = 0; k <= l; k++, path++) { + if (path->p_idx) { -+ ext_debug(tree, " %d->%d", path->p_idx->e_block, -+ path->p_idx->e_leaf); ++ ext_debug(tree, " %d->%d", path->p_idx->ei_block, ++ path->p_idx->ei_leaf); + } else if (path->p_ext) { + ext_debug(tree, " %d:%d:%d", -+ path->p_ext->e_block, -+ path->p_ext->e_num, -+ path->p_ext->e_start); ++ path->p_ext->ee_block, ++ path->p_ext->ee_len, ++ path->p_ext->ee_start); + } else + ext_debug(tree, " []"); + } @@ -235,7 +258,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +} + +static void ext3_ext_show_leaf(struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path) ++ struct ext3_ext_path *path) +{ +#ifdef EXT_DEBUG + int depth = EXT_DEPTH(tree); @@ -249,9 +272,9 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + eh = path[depth].p_hdr; + ex = EXT_FIRST_EXTENT(eh); + -+ for (i = 0; i < eh->e_num; i++, ex++) { ++ for (i = 0; i < eh->eh_entries; i++, ex++) { + ext_debug(tree, "%d:%d:%d ", -+ ex->e_block, ex->e_num, ex->e_start); ++ ex->ee_block, ex->ee_len, ex->ee_start); + } + ext_debug(tree, "\n"); +#endif @@ -262,11 +285,12 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + int depth = path->p_depth; + int i; + -+ for (i = 0; i <= depth; i++, path++) ++ for (i = 0; i <= depth; i++, path++) { + if (path->p_bh) { + brelse(path->p_bh); + path->p_bh = NULL; + } ++ } +} + +/* @@ -274,24 +298,24 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + */ +static inline void +ext3_ext_binsearch_idx(struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, int block) ++ struct ext3_ext_path *path, int block) +{ + struct ext3_extent_header *eh = path->p_hdr; + struct ext3_extent_idx *ix; + int l = 0, k, r; + -+ EXT_ASSERT(eh->e_magic == EXT3_EXT_MAGIC); -+ EXT_ASSERT(eh->e_num <= eh->e_max); -+ EXT_ASSERT(eh->e_num > 0); ++ EXT_ASSERT(eh->eh_magic == EXT3_EXT_MAGIC); ++ EXT_ASSERT(eh->eh_entries <= eh->eh_max); ++ EXT_ASSERT(eh->eh_entries > 0); + + ext_debug(tree, "binsearch for %d(idx): ", block); + + path->p_idx = ix = EXT_FIRST_INDEX(eh); + -+ r = k = eh->e_num; ++ r = k = eh->eh_entries; + while (k > 1) { + k = (r - l) / 2; -+ if (block < ix[l + k].e_block) ++ if (block < ix[l + k].ei_block) + r -= k; + else + l += k; @@ -300,37 +324,36 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + ix += l; + path->p_idx = ix; -+ ext_debug(tree, " -> %d->%d ", path->p_idx->e_block, path->p_idx->e_leaf); ++ ext_debug(tree," -> %d->%d ",path->p_idx->ei_block,path->p_idx->ei_leaf); + + while (l++ < r) { -+ if (block < ix->e_block) ++ if (block < ix->ei_block) + break; + path->p_idx = ix++; + } -+ ext_debug(tree, " -> %d->%d\n", path->p_idx->e_block, -+ path->p_idx->e_leaf); ++ ext_debug(tree, " -> %d->%d\n", path->p_idx->ei_block, ++ path->p_idx->ei_leaf); + +#ifdef CHECK_BINSEARCH + { + struct ext3_extent_idx *chix; + + chix = ix = EXT_FIRST_INDEX(eh); -+ for (k = 0; k < eh->e_num; k++, ix++) { -+ if (k != 0 && ix->e_block <= ix[-1].e_block) { ++ for (k = 0; k < eh->eh_entries; k++, ix++) { ++ if (k != 0 && ix->ei_block <= ix[-1].ei_block) { + printk("k=%d, ix=0x%p, first=0x%p\n", k, -+ ix, EXT_FIRST_INDEX(eh)); ++ ix, EXT_FIRST_INDEX(eh)); + printk("%u <= %u\n", -+ ix->e_block,ix[-1].e_block); ++ ix->ei_block,ix[-1].ei_block); + } -+ EXT_ASSERT(k == 0 || ix->e_block > ix[-1].e_block); -+ if (block < ix->e_block) ++ EXT_ASSERT(k == 0 || ix->ei_block > ix[-1].ei_block); ++ if (block < ix->ei_block) + break; + chix = ix; + } + EXT_ASSERT(chix == path->p_idx); + } +#endif -+ +} + +/* @@ -338,16 +361,16 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + */ +static inline void +ext3_ext_binsearch(struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, int block) ++ struct ext3_ext_path *path, int block) +{ + struct ext3_extent_header *eh = path->p_hdr; + struct ext3_extent *ex; + int l = 0, k, r; + -+ EXT_ASSERT(eh->e_magic == EXT3_EXT_MAGIC); -+ EXT_ASSERT(eh->e_num <= eh->e_max); ++ EXT_ASSERT(eh->eh_magic == EXT3_EXT_MAGIC); ++ EXT_ASSERT(eh->eh_entries <= eh->eh_max); + -+ if (eh->e_num == 0) { ++ if (eh->eh_entries == 0) { + /* + * this leaf is empty yet: + * we get such a leaf in split/add case @@ -359,10 +382,10 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + path->p_ext = ex = EXT_FIRST_EXTENT(eh); + -+ r = k = eh->e_num; ++ r = k = eh->eh_entries; + while (k > 1) { + k = (r - l) / 2; -+ if (block < ex[l + k].e_block) ++ if (block < ex[l + k].ee_block) + r -= k; + else + l += k; @@ -371,32 +394,31 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + ex += l; + path->p_ext = ex; -+ ext_debug(tree, " -> %d:%d:%d ", path->p_ext->e_block, -+ path->p_ext->e_start, path->p_ext->e_num); ++ ext_debug(tree, " -> %d:%d:%d ", path->p_ext->ee_block, ++ path->p_ext->ee_start, path->p_ext->ee_len); + + while (l++ < r) { -+ if (block < ex->e_block) ++ if (block < ex->ee_block) + break; + path->p_ext = ex++; + } -+ ext_debug(tree, " -> %d:%d:%d\n", path->p_ext->e_block, -+ path->p_ext->e_start, path->p_ext->e_num); ++ ext_debug(tree, " -> %d:%d:%d\n", path->p_ext->ee_block, ++ path->p_ext->ee_start, path->p_ext->ee_len); + +#ifdef CHECK_BINSEARCH + { + struct ext3_extent *chex; + + chex = ex = EXT_FIRST_EXTENT(eh); -+ for (k = 0; k < eh->e_num; k++, ex++) { -+ EXT_ASSERT(k == 0 || ex->e_block > ex[-1].e_block); -+ if (block < ex->e_block) ++ for (k = 0; k < eh->eh_entries; k++, ex++) { ++ EXT_ASSERT(k == 0 || ex->ee_block > ex[-1].ee_block); ++ if (block < ex->ee_block) + break; + chex = ex; + } + EXT_ASSERT(chex == path->p_ext); + } +#endif -+ +} + +int ext3_extent_tree_init(handle_t *handle, struct ext3_extents_tree *tree) @@ -406,17 +428,18 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + BUG_ON(tree->buffer_len == 0); + ext3_ext_get_access_for_root(handle, tree); + eh = EXT_ROOT_HDR(tree); -+ eh->e_depth = 0; -+ eh->e_num = 0; -+ eh->e_magic = EXT3_EXT_MAGIC; -+ eh->e_max = ext3_ext_space_root(tree); ++ eh->eh_depth = 0; ++ eh->eh_entries = 0; ++ eh->eh_magic = EXT3_EXT_MAGIC; ++ eh->eh_max = ext3_ext_space_root(tree); + ext3_ext_mark_root_dirty(handle, tree); ++ ext3_ext_invalidate_cache(tree); + return 0; +} + +struct ext3_ext_path * +ext3_ext_find_extent(struct ext3_extents_tree *tree, int block, -+ struct ext3_ext_path *path) ++ struct ext3_ext_path *path) +{ + struct ext3_extent_header *eh; + struct buffer_head *bh; @@ -427,15 +450,18 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + EXT_ASSERT(tree->root); + + eh = EXT_ROOT_HDR(tree); ++ EXT_ASSERT(eh); ++ if (ext3_ext_check_header(eh)) ++ goto err; ++ + i = depth = EXT_DEPTH(tree); -+ EXT_ASSERT(eh->e_max); -+ EXT_ASSERT(eh->e_magic == EXT3_EXT_MAGIC); -+ EXT_ASSERT(i == 0 || eh->e_num > 0); ++ EXT_ASSERT(eh->eh_max); ++ EXT_ASSERT(eh->eh_magic == EXT3_EXT_MAGIC); + + /* account possible depth increase */ + if (!path) { + path = kmalloc(sizeof(struct ext3_ext_path) * (depth + 2), -+ GFP_NOFS); ++ GFP_NOFS); + if (!path) + return ERR_PTR(-ENOMEM); + } @@ -445,29 +471,34 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + /* walk through the tree */ + while (i) { + ext_debug(tree, "depth %d: num %d, max %d\n", -+ ppos, eh->e_num, eh->e_max); ++ ppos, eh->eh_entries, eh->eh_max); + ext3_ext_binsearch_idx(tree, path + ppos, block); -+ path[ppos].p_block = path[ppos].p_idx->e_leaf; ++ path[ppos].p_block = path[ppos].p_idx->ei_leaf; + path[ppos].p_depth = i; + path[ppos].p_ext = NULL; + + bh = sb_bread(tree->inode->i_sb, path[ppos].p_block); -+ if (!bh) { -+ ext3_ext_drop_refs(path); -+ kfree(path); -+ return ERR_PTR(-EIO); -+ } ++ if (!bh) ++ goto err; ++ + eh = EXT_BLOCK_HDR(bh); + ppos++; + EXT_ASSERT(ppos <= depth); + path[ppos].p_bh = bh; + path[ppos].p_hdr = eh; + i--; ++ ++ if (ext3_ext_check_header(eh)) ++ goto err; + } + + path[ppos].p_depth = i; + path[ppos].p_hdr = eh; + path[ppos].p_ext = NULL; ++ path[ppos].p_idx = NULL; ++ ++ if (ext3_ext_check_header(eh)) ++ goto err; + + /* find extent */ + ext3_ext_binsearch(tree, path + ppos, block); @@ -475,6 +506,12 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + ext3_ext_show_path(tree, path); + + return path; ++ ++err: ++ printk(KERN_ERR "EXT3-fs: header is corrupted!\n"); ++ ext3_ext_drop_refs(path); ++ kfree(path); ++ return ERR_PTR(-EIO); +} + +/* @@ -482,9 +519,9 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * it check where to insert: before curp or after curp + */ +static int ext3_ext_insert_index(handle_t *handle, -+ struct ext3_extents_tree *tree, -+ struct ext3_ext_path *curp, -+ int logical, int ptr) ++ struct ext3_extents_tree *tree, ++ struct ext3_ext_path *curp, ++ int logical, int ptr) +{ + struct ext3_extent_idx *ix; + int len, err; @@ -492,17 +529,17 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + if ((err = ext3_ext_get_access(handle, tree, curp))) + return err; + -+ EXT_ASSERT(logical != curp->p_idx->e_block); ++ EXT_ASSERT(logical != curp->p_idx->ei_block); + len = EXT_MAX_INDEX(curp->p_hdr) - curp->p_idx; -+ if (logical > curp->p_idx->e_block) { ++ if (logical > curp->p_idx->ei_block) { + /* insert after */ + if (curp->p_idx != EXT_LAST_INDEX(curp->p_hdr)) { + len = (len - 1) * sizeof(struct ext3_extent_idx); + len = len < 0 ? 0 : len; + ext_debug(tree, "insert new index %d after: %d. " -+ "move %d from 0x%p to 0x%p\n", -+ logical, ptr, len, -+ (curp->p_idx + 1), (curp->p_idx + 2)); ++ "move %d from 0x%p to 0x%p\n", ++ logical, ptr, len, ++ (curp->p_idx + 1), (curp->p_idx + 2)); + memmove(curp->p_idx + 2, curp->p_idx + 1, len); + } + ix = curp->p_idx + 1; @@ -511,18 +548,19 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + len = len * sizeof(struct ext3_extent_idx); + len = len < 0 ? 0 : len; + ext_debug(tree, "insert new index %d before: %d. " -+ "move %d from 0x%p to 0x%p\n", -+ logical, ptr, len, -+ curp->p_idx, (curp->p_idx + 1)); ++ "move %d from 0x%p to 0x%p\n", ++ logical, ptr, len, ++ curp->p_idx, (curp->p_idx + 1)); + memmove(curp->p_idx + 1, curp->p_idx, len); + ix = curp->p_idx; + } + -+ ix->e_block = logical; -+ ix->e_leaf = ptr; -+ curp->p_hdr->e_num++; ++ ix->ei_block = logical; ++ ix->ei_leaf = ptr; ++ ix->ei_leaf_hi = ix->ei_unused = 0; ++ curp->p_hdr->eh_entries++; + -+ EXT_ASSERT(curp->p_hdr->e_num <= curp->p_hdr->e_max); ++ EXT_ASSERT(curp->p_hdr->eh_entries <= curp->p_hdr->eh_max); + EXT_ASSERT(ix <= EXT_LAST_INDEX(curp->p_hdr)); + + err = ext3_ext_dirty(handle, tree, curp); @@ -541,8 +579,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * - initialize subtree + */ +static int ext3_ext_split(handle_t *handle, struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, -+ struct ext3_extent *newext, int at) ++ struct ext3_ext_path *path, ++ struct ext3_extent *newext, int at) +{ + struct buffer_head *bh = NULL; + int depth = EXT_DEPTH(tree); @@ -561,15 +599,15 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * border from split point */ + EXT_ASSERT(path[depth].p_ext <= EXT_MAX_EXTENT(path[depth].p_hdr)); + if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) { -+ border = path[depth].p_ext[1].e_block; ++ border = path[depth].p_ext[1].ee_block; + ext_debug(tree, "leaf will be splitted." -+ " next leaf starts at %d\n", -+ (int)border); ++ " next leaf starts at %d\n", ++ (int)border); + } else { -+ border = newext->e_block; ++ border = newext->ee_block; + ext_debug(tree, "leaf will be added." -+ " next leaf starts at %d\n", -+ (int)border); ++ " next leaf starts at %d\n", ++ (int)border); + } + + /* @@ -612,14 +650,14 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + goto cleanup; + + neh = EXT_BLOCK_HDR(bh); -+ neh->e_num = 0; -+ neh->e_max = ext3_ext_space_block(tree); -+ neh->e_magic = EXT3_EXT_MAGIC; -+ neh->e_depth = 0; ++ neh->eh_entries = 0; ++ neh->eh_max = ext3_ext_space_block(tree); ++ neh->eh_magic = EXT3_EXT_MAGIC; ++ neh->eh_depth = 0; + ex = EXT_FIRST_EXTENT(neh); + + /* move remain of path[depth] to the new leaf */ -+ EXT_ASSERT(path[depth].p_hdr->e_num == path[depth].p_hdr->e_max); ++ EXT_ASSERT(path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max); + /* start copy from next extent */ + /* TODO: we could do it by single memmove */ + m = 0; @@ -627,13 +665,12 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + while (path[depth].p_ext <= + EXT_MAX_EXTENT(path[depth].p_hdr)) { + ext_debug(tree, "move %d:%d:%d in new leaf %lu\n", -+ path[depth].p_ext->e_block, -+ path[depth].p_ext->e_start, -+ path[depth].p_ext->e_num, -+ newblock); -+ memmove(ex++, path[depth].p_ext++, -+ sizeof(struct ext3_extent)); -+ neh->e_num++; ++ path[depth].p_ext->ee_block, ++ path[depth].p_ext->ee_start, ++ path[depth].p_ext->ee_len, ++ newblock); ++ memmove(ex++, path[depth].p_ext++, sizeof(struct ext3_extent)); ++ neh->eh_entries++; + m++; + } + mark_buffer_uptodate(bh, 1); @@ -648,7 +685,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + if (m) { + if ((err = ext3_ext_get_access(handle, tree, path + depth))) + goto cleanup; -+ path[depth].p_hdr->e_num -= m; ++ path[depth].p_hdr->eh_entries -= m; + if ((err = ext3_ext_dirty(handle, tree, path + depth))) + goto cleanup; + @@ -676,32 +713,33 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + goto cleanup; + + neh = EXT_BLOCK_HDR(bh); -+ neh->e_num = 1; -+ neh->e_magic = EXT3_EXT_MAGIC; -+ neh->e_max = ext3_ext_space_block_idx(tree); -+ neh->e_depth = depth - i; ++ neh->eh_entries = 1; ++ neh->eh_magic = EXT3_EXT_MAGIC; ++ neh->eh_max = ext3_ext_space_block_idx(tree); ++ neh->eh_depth = depth - i; + fidx = EXT_FIRST_INDEX(neh); -+ fidx->e_block = border; -+ fidx->e_leaf = oldblock; ++ fidx->ei_block = border; ++ fidx->ei_leaf = oldblock; ++ fidx->ei_leaf_hi = fidx->ei_unused = 0; + + ext_debug(tree, "int.index at %d (block %lu): %lu -> %lu\n", -+ i, newblock, border, oldblock); ++ i, newblock, border, oldblock); + /* copy indexes */ + m = 0; + path[i].p_idx++; + + ext_debug(tree, "cur 0x%p, last 0x%p\n", path[i].p_idx, -+ EXT_MAX_INDEX(path[i].p_hdr)); ++ EXT_MAX_INDEX(path[i].p_hdr)); + EXT_ASSERT(EXT_MAX_INDEX(path[i].p_hdr) == -+ EXT_LAST_INDEX(path[i].p_hdr)); ++ EXT_LAST_INDEX(path[i].p_hdr)); + while (path[i].p_idx <= EXT_MAX_INDEX(path[i].p_hdr)) { + ext_debug(tree, "%d: move %d:%d in new index %lu\n", -+ i, path[i].p_idx->e_block, -+ path[i].p_idx->e_leaf, newblock); ++ i, path[i].p_idx->ei_block, ++ path[i].p_idx->ei_leaf, newblock); + memmove(++fidx, path[i].p_idx++, -+ sizeof(struct ext3_extent_idx)); -+ neh->e_num++; -+ EXT_ASSERT(neh->e_num <= neh->e_max); ++ sizeof(struct ext3_extent_idx)); ++ neh->eh_entries++; ++ EXT_ASSERT(neh->eh_entries <= neh->eh_max); + m++; + } + mark_buffer_uptodate(bh, 1); @@ -717,7 +755,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + err = ext3_ext_get_access(handle, tree, path + i); + if (err) + goto cleanup; -+ path[i].p_hdr->e_num -= m; ++ path[i].p_hdr->eh_entries -= m; + err = ext3_ext_dirty(handle, tree, path + i); + if (err) + goto cleanup; @@ -729,7 +767,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + /* insert new index */ + if (!err) + err = ext3_ext_insert_index(handle, tree, path + at, -+ border, newblock); ++ border, newblock); + +cleanup: + if (bh) { @@ -740,10 +778,11 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + if (err) { + /* free all allocated blocks in error case */ -+ for (i = 0; i < depth; i++) ++ for (i = 0; i < depth; i++) { + if (!ablocks[i]) + continue; + ext3_free_blocks(handle, tree->inode, ablocks[i], 1); ++ } + } + kfree(ablocks); + @@ -758,9 +797,9 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * just created block + */ +static int ext3_ext_grow_indepth(handle_t *handle, -+ struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, -+ struct ext3_extent *newext) ++ struct ext3_extents_tree *tree, ++ struct ext3_ext_path *path, ++ struct ext3_extent *newext) +{ + struct ext3_ext_path *curp = path; + struct ext3_extent_header *neh; @@ -792,12 +831,12 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + /* set size of new block */ + neh = EXT_BLOCK_HDR(bh); + /* old root could have indexes or leaves -+ * so calculate e_max right way */ ++ * so calculate eh_max right way */ + if (EXT_DEPTH(tree)) -+ neh->e_max = ext3_ext_space_block_idx(tree); ++ neh->eh_max = ext3_ext_space_block_idx(tree); + else -+ neh->e_max = ext3_ext_space_block(tree); -+ neh->e_magic = EXT3_EXT_MAGIC; ++ neh->eh_max = ext3_ext_space_block(tree); ++ neh->eh_magic = EXT3_EXT_MAGIC; + mark_buffer_uptodate(bh, 1); + unlock_buffer(bh); + @@ -808,20 +847,21 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + if ((err = ext3_ext_get_access(handle, tree, curp))) + goto out; + -+ curp->p_hdr->e_magic = EXT3_EXT_MAGIC; -+ curp->p_hdr->e_max = ext3_ext_space_root_idx(tree); -+ curp->p_hdr->e_num = 1; ++ curp->p_hdr->eh_magic = EXT3_EXT_MAGIC; ++ curp->p_hdr->eh_max = ext3_ext_space_root_idx(tree); ++ curp->p_hdr->eh_entries = 1; + curp->p_idx = EXT_FIRST_INDEX(curp->p_hdr); + /* FIXME: it works, but actually path[0] can be index */ -+ curp->p_idx->e_block = EXT_FIRST_EXTENT(path[0].p_hdr)->e_block; -+ curp->p_idx->e_leaf = newblock; ++ curp->p_idx->ei_block = EXT_FIRST_EXTENT(path[0].p_hdr)->ee_block; ++ curp->p_idx->ei_leaf = newblock; ++ curp->p_idx->ei_leaf_hi = curp->p_idx->ei_unused = 0; + + neh = EXT_ROOT_HDR(tree); + fidx = EXT_FIRST_INDEX(neh); + ext_debug(tree, "new root: num %d(%d), lblock %d, ptr %d\n", -+ neh->e_num, neh->e_max, fidx->e_block, fidx->e_leaf); ++ neh->eh_entries, neh->eh_max, fidx->ei_block, fidx->ei_leaf); + -+ neh->e_depth = path->p_depth + 1; ++ neh->eh_depth = path->p_depth + 1; + err = ext3_ext_dirty(handle, tree, curp); +out: + brelse(bh); @@ -834,9 +874,9 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * then it requests in-depth growing + */ +static int ext3_ext_create_new_leaf(handle_t *handle, -+ struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, -+ struct ext3_extent *newext) ++ struct ext3_extents_tree *tree, ++ struct ext3_ext_path *path, ++ struct ext3_extent *newext) +{ + struct ext3_ext_path *curp; + int depth, i, err = 0; @@ -860,7 +900,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + /* refill path */ + ext3_ext_drop_refs(path); -+ path = ext3_ext_find_extent(tree, newext->e_block, path); ++ path = ext3_ext_find_extent(tree, newext->ee_block, path); + if (IS_ERR(path)) + err = PTR_ERR(path); + } else { @@ -869,7 +909,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + /* refill path */ + ext3_ext_drop_refs(path); -+ path = ext3_ext_find_extent(tree, newext->e_block, path); ++ path = ext3_ext_find_extent(tree, newext->ee_block, path); + if (IS_ERR(path)) + err = PTR_ERR(path); + @@ -878,7 +918,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * in all other cases we have to split growed tree + */ + depth = EXT_DEPTH(tree); -+ if (path[depth].p_hdr->e_num == path[depth].p_hdr->e_max) { ++ if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) { + /* now we need split */ + goto repeat; + } @@ -891,7 +931,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +} + +/* -+ * returns allocated block in subsequent extent or 0xffffffff ++ * returns allocated block in subsequent extent or EXT_MAX_BLOCK + * NOTE: it consider block number from index entry as + * allocated block. thus, index entries have to be consistent + * with leafs @@ -905,32 +945,32 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + depth = path->p_depth; + + if (depth == 0 && path->p_ext == NULL) -+ return 0xffffffff; ++ return EXT_MAX_BLOCK; + + /* FIXME: what if index isn't full ?! */ + while (depth >= 0) { + if (depth == path->p_depth) { + /* leaf */ + if (path[depth].p_ext != -+ EXT_LAST_EXTENT(path[depth].p_hdr)) -+ return path[depth].p_ext[1].e_block; ++ EXT_LAST_EXTENT(path[depth].p_hdr)) ++ return path[depth].p_ext[1].ee_block; + } else { + /* index */ + if (path[depth].p_idx != -+ EXT_LAST_INDEX(path[depth].p_hdr)) -+ return path[depth].p_idx[1].e_block; ++ EXT_LAST_INDEX(path[depth].p_hdr)) ++ return path[depth].p_idx[1].ei_block; + } + depth--; + } + -+ return 0xffffffff; ++ return EXT_MAX_BLOCK; +} + +/* -+ * returns first allocated block from next leaf or 0xffffffff ++ * returns first allocated block from next leaf or EXT_MAX_BLOCK + */ +static unsigned ext3_ext_next_leaf_block(struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path) ++ struct ext3_ext_path *path) +{ + int depth; + @@ -939,19 +979,19 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + /* zero-tree has no leaf blocks at all */ + if (depth == 0) -+ return 0xffffffff; ++ return EXT_MAX_BLOCK; + + /* go to index block */ + depth--; + + while (depth >= 0) { + if (path[depth].p_idx != -+ EXT_LAST_INDEX(path[depth].p_hdr)) -+ return path[depth].p_idx[1].e_block; ++ EXT_LAST_INDEX(path[depth].p_hdr)) ++ return path[depth].p_idx[1].ei_block; + depth--; + } + -+ return 0xffffffff; ++ return EXT_MAX_BLOCK; +} + +/* @@ -960,7 +1000,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * TODO: do we need to correct tree in all cases? + */ +int ext3_ext_correct_indexes(handle_t *handle, struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path) ++ struct ext3_ext_path *path) +{ + struct ext3_extent_header *eh; + int depth = EXT_DEPTH(tree); @@ -987,10 +1027,10 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * TODO: we need correction if border is smaller then current one + */ + k = depth - 1; -+ border = path[depth].p_ext->e_block; ++ border = path[depth].p_ext->ee_block; + if ((err = ext3_ext_get_access(handle, tree, path + k))) + return err; -+ path[k].p_idx->e_block = border; ++ path[k].p_idx->ei_block = border; + if ((err = ext3_ext_dirty(handle, tree, path + k))) + return err; + @@ -1000,7 +1040,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + break; + if ((err = ext3_ext_get_access(handle, tree, path + k))) + break; -+ path[k].p_idx->e_block = border; ++ path[k].p_idx->ei_block = border; + if ((err = ext3_ext_dirty(handle, tree, path + k))) + break; + } @@ -1010,21 +1050,21 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + +static int inline +ext3_can_extents_be_merged(struct ext3_extents_tree *tree, -+ struct ext3_extent *ex1, -+ struct ext3_extent *ex2) ++ struct ext3_extent *ex1, ++ struct ext3_extent *ex2) +{ -+ if (ex1->e_block + ex1->e_num != ex2->e_block) ++ if (ex1->ee_block + ex1->ee_len != ex2->ee_block) + return 0; + +#ifdef AGRESSIVE_TEST -+ if (ex1->e_num >= 4) ++ if (ex1->ee_len >= 4) + return 0; +#endif + -+ if (!tree->mergable) ++ if (!tree->ops->mergable) + return 1; + -+ return tree->mergable(ex1, ex2); ++ return tree->ops->mergable(ex1, ex2); +} + +/* @@ -1033,8 +1073,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * creating new leaf in no-space case + */ +int ext3_ext_insert_extent(handle_t *handle, struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, -+ struct ext3_extent *newext) ++ struct ext3_ext_path *path, ++ struct ext3_extent *newext) +{ + struct ext3_extent_header * eh; + struct ext3_extent *ex, *fex; @@ -1042,17 +1082,19 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + struct ext3_ext_path *npath = NULL; + int depth, len, err, next; + ++ EXT_ASSERT(newext->ee_len > 0); + depth = EXT_DEPTH(tree); + ex = path[depth].p_ext; ++ EXT_ASSERT(path[depth].p_hdr); + + /* try to insert block into found extent and return */ + if (ex && ext3_can_extents_be_merged(tree, ex, newext)) { + ext_debug(tree, "append %d block to %d:%d (from %d)\n", -+ newext->e_num, ex->e_block, ex->e_num, -+ ex->e_start); ++ newext->ee_len, ex->ee_block, ex->ee_len, ++ ex->ee_start); + if ((err = ext3_ext_get_access(handle, tree, path + depth))) + return err; -+ ex->e_num += newext->e_num; ++ ex->ee_len += newext->ee_len; + eh = path[depth].p_hdr; + nearex = ex; + goto merge; @@ -1061,13 +1103,13 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +repeat: + depth = EXT_DEPTH(tree); + eh = path[depth].p_hdr; -+ if (eh->e_num < eh->e_max) ++ if (eh->eh_entries < eh->eh_max) + goto has_space; + + /* probably next leaf has space for us? */ + fex = EXT_LAST_EXTENT(eh); + next = ext3_ext_next_leaf_block(tree, path); -+ if (newext->e_block > fex->e_block && next != 0xffffffff) { ++ if (newext->ee_block > fex->ee_block && next != EXT_MAX_BLOCK) { + ext_debug(tree, "next leaf block - %d\n", next); + EXT_ASSERT(!npath); + npath = ext3_ext_find_extent(tree, next, NULL); @@ -1075,14 +1117,14 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + return PTR_ERR(npath); + EXT_ASSERT(npath->p_depth == path->p_depth); + eh = npath[depth].p_hdr; -+ if (eh->e_num < eh->e_max) { ++ if (eh->eh_entries < eh->eh_max) { + ext_debug(tree, "next leaf isnt full(%d)\n", -+ eh->e_num); ++ eh->eh_entries); + path = npath; + goto repeat; + } + ext_debug(tree, "next leaf hasno free space(%d,%d)\n", -+ eh->e_num, eh->e_max); ++ eh->eh_entries, eh->eh_max); + } + + /* @@ -1104,40 +1146,42 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + if (!nearex) { + /* there is no extent in this leaf, create first one */ + ext_debug(tree, "first extent in the leaf: %d:%d:%d\n", -+ newext->e_block, newext->e_start, -+ newext->e_num); ++ newext->ee_block, newext->ee_start, ++ newext->ee_len); + path[depth].p_ext = EXT_FIRST_EXTENT(eh); -+ } else if (newext->e_block > nearex->e_block) { -+ EXT_ASSERT(newext->e_block != nearex->e_block); ++ } else if (newext->ee_block > nearex->ee_block) { ++ EXT_ASSERT(newext->ee_block != nearex->ee_block); + if (nearex != EXT_LAST_EXTENT(eh)) { + len = EXT_MAX_EXTENT(eh) - nearex; + len = (len - 1) * sizeof(struct ext3_extent); + len = len < 0 ? 0 : len; + ext_debug(tree, "insert %d:%d:%d after: nearest 0x%p, " -+ "move %d from 0x%p to 0x%p\n", -+ newext->e_block, newext->e_start, -+ newext->e_num, -+ nearex, len, nearex + 1, nearex + 2); ++ "move %d from 0x%p to 0x%p\n", ++ newext->ee_block, newext->ee_start, ++ newext->ee_len, ++ nearex, len, nearex + 1, nearex + 2); + memmove(nearex + 2, nearex + 1, len); + } + path[depth].p_ext = nearex + 1; + } else { -+ EXT_ASSERT(newext->e_block != nearex->e_block); ++ EXT_ASSERT(newext->ee_block != nearex->ee_block); + len = (EXT_MAX_EXTENT(eh) - nearex) * sizeof(struct ext3_extent); + len = len < 0 ? 0 : len; + ext_debug(tree, "insert %d:%d:%d before: nearest 0x%p, " -+ "move %d from 0x%p to 0x%p\n", -+ newext->e_block, newext->e_start, newext->e_num, -+ nearex, len, nearex + 1, nearex + 2); ++ "move %d from 0x%p to 0x%p\n", ++ newext->ee_block, newext->ee_start, newext->ee_len, ++ nearex, len, nearex + 1, nearex + 2); + memmove(nearex + 1, nearex, len); + path[depth].p_ext = nearex; + } + -+ eh->e_num++; ++ eh->eh_entries++; + nearex = path[depth].p_ext; -+ nearex->e_block = newext->e_block; -+ nearex->e_start = newext->e_start; -+ nearex->e_num = newext->e_num; ++ nearex->ee_block = newext->ee_block; ++ nearex->ee_start = newext->ee_start; ++ nearex->ee_len = newext->ee_len; ++ /* FIXME: support for large fs */ ++ nearex->ee_start_hi = 0; + +merge: + /* try to merge extents to the right */ @@ -1145,14 +1189,14 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + if (!ext3_can_extents_be_merged(tree, nearex, nearex + 1)) + break; + /* merge with next extent! */ -+ nearex->e_num += nearex[1].e_num; ++ nearex->ee_len += nearex[1].ee_len; + if (nearex + 1 < EXT_LAST_EXTENT(eh)) { -+ len = (EXT_LAST_EXTENT(eh) - nearex - 1) -+ * sizeof(struct ext3_extent); ++ len = (EXT_LAST_EXTENT(eh) - nearex - 1) * ++ sizeof(struct ext3_extent); + memmove(nearex + 1, nearex + 2, len); + } -+ eh->e_num--; -+ EXT_ASSERT(eh->e_num > 0); ++ eh->eh_entries--; ++ EXT_ASSERT(eh->eh_entries > 0); + } + + /* try to merge extents to the left */ @@ -1170,6 +1214,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + kfree(npath); + } + ext3_ext_tree_changed(tree); ++ ext3_ext_invalidate_cache(tree); + return err; +} + @@ -1177,7 +1222,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + unsigned long num, ext_prepare_callback func) +{ + struct ext3_ext_path *path = NULL; -+ struct ext3_extent *ex, cbex; ++ struct ext3_ext_cache cbex; ++ struct ext3_extent *ex; + unsigned long next, start = 0, end = 0; + unsigned long last = block + num; + int depth, exists, err = 0; @@ -1187,7 +1233,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + EXT_ASSERT(tree->inode); + EXT_ASSERT(tree->root); + -+ while (block < last && block != 0xfffffffff) { ++ while (block < last && block != EXT_MAX_BLOCK) { + num = last - block; + /* find extent for this block */ + path = ext3_ext_find_extent(tree, block, path); @@ -1198,6 +1244,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + } + + depth = EXT_DEPTH(tree); ++ EXT_ASSERT(path[depth].p_hdr); + ex = path[depth].p_ext; + next = ext3_ext_next_allocated_block(path); + @@ -1207,25 +1254,25 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * all requested space */ + start = block; + end = block + num; -+ } else if (ex->e_block > block) { ++ } else if (ex->ee_block > block) { + /* need to allocate space before found extent */ + start = block; -+ end = ex->e_block; ++ end = ex->ee_block; + if (block + num < end) + end = block + num; -+ } else if (block >= ex->e_block + ex->e_num) { ++ } else if (block >= ex->ee_block + ex->ee_len) { + /* need to allocate space after found extent */ + start = block; + end = block + num; + if (end >= next) + end = next; -+ } else if (block >= ex->e_block) { ++ } else if (block >= ex->ee_block) { + /* + * some part of requested space is covered + * by found extent + */ + start = block; -+ end = ex->e_block + ex->e_num; ++ end = ex->ee_block + ex->ee_len; + if (block + num < end) + end = block + num; + exists = 1; @@ -1235,13 +1282,20 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + EXT_ASSERT(end > start); + + if (!exists) { -+ cbex.e_block = start; -+ cbex.e_num = end - start; -+ cbex.e_start = 0; -+ } else -+ cbex = *ex; ++ cbex.ec_block = start; ++ cbex.ec_len = end - start; ++ cbex.ec_start = 0; ++ cbex.ec_type = EXT3_EXT_CACHE_GAP; ++ } else { ++ cbex.ec_block = ex->ee_block; ++ cbex.ec_len = ex->ee_len; ++ cbex.ec_start = ex->ee_start; ++ cbex.ec_type = EXT3_EXT_CACHE_EXTENT; ++ } + -+ err = func(tree, path, &cbex, exists); ++ EXT_ASSERT(cbex.ec_len > 0); ++ EXT_ASSERT(path[depth].p_hdr); ++ err = func(tree, path, &cbex); + ext3_ext_drop_refs(path); + + if (err < 0) @@ -1259,7 +1313,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + path = NULL; + } + -+ block = cbex.e_block + cbex.e_num; ++ block = cbex.ec_block + cbex.ec_len; + } + + if (path) { @@ -1271,21 +1325,15 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +} + +static inline void -+ext3_ext_invalidate_cache(struct ext3_extents_tree *tree) -+{ -+ if (tree->cex) -+ tree->cex->e_num = 0; -+} -+ -+static inline void -+ext3_ext_put_in_cache(struct ext3_extents_tree *tree, struct ext3_extent *ex) ++ext3_ext_put_in_cache(struct ext3_extents_tree *tree, __u32 block, ++ __u32 len, __u32 start, int type) +{ ++ EXT_ASSERT(len > 0); + if (tree->cex) { -+ EXT_ASSERT(ex); -+ EXT_ASSERT(ex->e_num); -+ tree->cex->e_block = ex->e_block; -+ tree->cex->e_start = ex->e_start; -+ tree->cex->e_num = ex->e_num; ++ tree->cex->ec_type = type; ++ tree->cex->ec_block = block; ++ tree->cex->ec_len = len; ++ tree->cex->ec_start = start; + } +} + @@ -1295,11 +1343,12 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + */ +static inline void +ext3_ext_put_gap_in_cache(struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, -+ unsigned long block) ++ struct ext3_ext_path *path, ++ unsigned long block) +{ + int depth = EXT_DEPTH(tree); -+ struct ext3_extent *ex, gex; ++ unsigned long lblock, len; ++ struct ext3_extent *ex; + + if (!tree->cex) + return; @@ -1307,63 +1356,65 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + ex = path[depth].p_ext; + if (ex == NULL) { + /* there is no extent yet, so gap is [0;-] */ -+ gex.e_block = 0; -+ gex.e_num = 0xffffffff; ++ lblock = 0; ++ len = EXT_MAX_BLOCK; + ext_debug(tree, "cache gap(whole file):"); -+ } else if (block < ex->e_block) { -+ gex.e_block = block; -+ gex.e_num = ex->e_block - block; ++ } else if (block < ex->ee_block) { ++ lblock = block; ++ len = ex->ee_block - block; + ext_debug(tree, "cache gap(before): %lu [%lu:%lu]", -+ (unsigned long) block, -+ (unsigned long) ex->e_block, -+ (unsigned long) ex->e_num); -+ } else if (block >= ex->e_block + ex->e_num) { -+ gex.e_block = ex->e_block + ex->e_num; -+ gex.e_num = ext3_ext_next_allocated_block(path); ++ (unsigned long) block, ++ (unsigned long) ex->ee_block, ++ (unsigned long) ex->ee_len); ++ } else if (block >= ex->ee_block + ex->ee_len) { ++ lblock = ex->ee_block + ex->ee_len; ++ len = ext3_ext_next_allocated_block(path); + ext_debug(tree, "cache gap(after): [%lu:%lu] %lu", -+ (unsigned long) ex->e_block, -+ (unsigned long) ex->e_num, -+ (unsigned long) block); -+ EXT_ASSERT(gex.e_num > gex.e_block); -+ gex.e_num = gex.e_num - gex.e_block; ++ (unsigned long) ex->ee_block, ++ (unsigned long) ex->ee_len, ++ (unsigned long) block); ++ EXT_ASSERT(len > lblock); ++ len = len - lblock; + } else { ++ lblock = len = 0; + BUG(); + } + -+ ext_debug(tree, " -> %lu:%lu\n", (unsigned long) gex.e_block, -+ (unsigned long) gex.e_num); -+ gex.e_start = 0xffffffff; -+ ext3_ext_put_in_cache(tree, &gex); ++ ext_debug(tree, " -> %lu:%lu\n", (unsigned long) lblock, len); ++ ext3_ext_put_in_cache(tree, lblock, len, 0, EXT3_EXT_CACHE_GAP); +} + +static inline int +ext3_ext_in_cache(struct ext3_extents_tree *tree, unsigned long block, -+ struct ext3_extent *ex) ++ struct ext3_extent *ex) +{ -+ struct ext3_extent *cex = tree->cex; ++ struct ext3_ext_cache *cex = tree->cex; + + /* is there cache storage at all? */ + if (!cex) -+ return 0; ++ return EXT3_EXT_CACHE_NO; + + /* has cache valid data? */ -+ if (cex->e_num == 0) -+ return 0; -+ -+ if (block >= cex->e_block && block < cex->e_block + cex->e_num) { -+ ex->e_block = cex->e_block; -+ ex->e_start = cex->e_start; -+ ex->e_num = cex->e_num; ++ if (cex->ec_type == EXT3_EXT_CACHE_NO) ++ return EXT3_EXT_CACHE_NO; ++ ++ EXT_ASSERT(cex->ec_type == EXT3_EXT_CACHE_GAP || ++ cex->ec_type == EXT3_EXT_CACHE_EXTENT); ++ if (block >= cex->ec_block && block < cex->ec_block + cex->ec_len) { ++ ex->ee_block = cex->ec_block; ++ ex->ee_start = cex->ec_start; ++ ex->ee_start_hi = 0; ++ ex->ee_len = cex->ec_len; + ext_debug(tree, "%lu cached by %lu:%lu:%lu\n", -+ (unsigned long) block, -+ (unsigned long) ex->e_block, -+ (unsigned long) ex->e_num, -+ (unsigned long) ex->e_start); -+ return 1; ++ (unsigned long) block, ++ (unsigned long) ex->ee_block, ++ (unsigned long) ex->ee_len, ++ (unsigned long) ex->ee_start); ++ return cex->ec_type; + } + + /* not in cache */ -+ return 0; ++ return EXT3_EXT_CACHE_NO; +} + +/* @@ -1372,36 +1423,36 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * last index in the block only + */ +int ext3_ext_rm_idx(handle_t *handle, struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path) ++ struct ext3_ext_path *path) +{ + struct buffer_head *bh; + int err; + + /* free index block */ + path--; -+ EXT_ASSERT(path->p_hdr->e_num); ++ EXT_ASSERT(path->p_hdr->eh_entries); + if ((err = ext3_ext_get_access(handle, tree, path))) + return err; -+ path->p_hdr->e_num--; ++ path->p_hdr->eh_entries--; + if ((err = ext3_ext_dirty(handle, tree, path))) + return err; + ext_debug(tree, "index is empty, remove it, free block %d\n", -+ path->p_idx->e_leaf); -+ bh = sb_get_hash_table(tree->inode->i_sb, path->p_idx->e_leaf); -+ ext3_forget(handle, 1, tree->inode, bh, path->p_idx->e_leaf); -+ ext3_free_blocks(handle, tree->inode, path->p_idx->e_leaf, 1); ++ path->p_idx->ei_leaf); ++ bh = sb_get_hash_table(tree->inode->i_sb, path->p_idx->ei_leaf); ++ ext3_forget(handle, 1, tree->inode, bh, path->p_idx->ei_leaf); ++ ext3_free_blocks(handle, tree->inode, path->p_idx->ei_leaf, 1); + return err; +} + +int ext3_ext_calc_credits_for_insert(struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path) ++ struct ext3_ext_path *path) +{ + int depth = EXT_DEPTH(tree); + int needed; + + if (path) { + /* probably there is space in leaf? */ -+ if (path[depth].p_hdr->e_num < path[depth].p_hdr->e_max) ++ if (path[depth].p_hdr->eh_entries < path[depth].p_hdr->eh_max) + return 1; + } + @@ -1431,8 +1482,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + +static int +ext3_ext_split_for_rm(handle_t *handle, struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, unsigned long start, -+ unsigned long end) ++ struct ext3_ext_path *path, unsigned long start, ++ unsigned long end) +{ + struct ext3_extent *ex, tex; + struct ext3_ext_path *npath; @@ -1441,13 +1492,13 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + depth = EXT_DEPTH(tree); + ex = path[depth].p_ext; + EXT_ASSERT(ex); -+ EXT_ASSERT(end < ex->e_block + ex->e_num - 1); -+ EXT_ASSERT(ex->e_block < start); ++ EXT_ASSERT(end < ex->ee_block + ex->ee_len - 1); ++ EXT_ASSERT(ex->ee_block < start); + + /* calculate tail extent */ -+ tex.e_block = end + 1; -+ EXT_ASSERT(tex.e_block < ex->e_block + ex->e_num); -+ tex.e_num = ex->e_block + ex->e_num - tex.e_block; ++ tex.ee_block = end + 1; ++ EXT_ASSERT(tex.ee_block < ex->ee_block + ex->ee_len); ++ tex.ee_len = ex->ee_block + ex->ee_len - tex.ee_block; + + creds = ext3_ext_calc_credits_for_insert(tree, path); + handle = ext3_ext_journal_restart(handle, creds); @@ -1458,35 +1509,34 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + err = ext3_ext_get_access(handle, tree, path + depth); + if (err) + return err; -+ ex->e_num = start - ex->e_block; ++ ex->ee_len = start - ex->ee_block; + err = ext3_ext_dirty(handle, tree, path + depth); + if (err) + return err; + + /* FIXME: some callback to free underlying resource -+ * and correct e_start? */ ++ * and correct ee_start? */ + ext_debug(tree, "split extent: head %u:%u, tail %u:%u\n", -+ ex->e_block, ex->e_num, tex.e_block, tex.e_num); ++ ex->ee_block, ex->ee_len, tex.ee_block, tex.ee_len); + -+ npath = ext3_ext_find_extent(tree, ex->e_block, NULL); ++ npath = ext3_ext_find_extent(tree, ex->ee_block, NULL); + if (IS_ERR(npath)) + return PTR_ERR(npath); + depth = EXT_DEPTH(tree); -+ EXT_ASSERT(npath[depth].p_ext->e_block == ex->e_block); -+ EXT_ASSERT(npath[depth].p_ext->e_num == ex->e_num); ++ EXT_ASSERT(npath[depth].p_ext->ee_block == ex->ee_block); ++ EXT_ASSERT(npath[depth].p_ext->ee_len == ex->ee_len); + + err = ext3_ext_insert_extent(handle, tree, npath, &tex); + ext3_ext_drop_refs(npath); + kfree(npath); + + return err; -+ +} + +static int +ext3_ext_rm_leaf(handle_t *handle, struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, unsigned long start, -+ unsigned long end) ++ struct ext3_ext_path *path, unsigned long start, ++ unsigned long end) +{ + struct ext3_extent *ex, *fu = NULL, *lu, *le; + int err = 0, correct_index = 0; @@ -1499,18 +1549,18 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + path[depth].p_hdr = EXT_BLOCK_HDR(path[depth].p_bh); + eh = path[depth].p_hdr; + EXT_ASSERT(eh); -+ EXT_ASSERT(eh->e_num <= eh->e_max); -+ EXT_ASSERT(eh->e_magic == EXT3_EXT_MAGIC); ++ EXT_ASSERT(eh->eh_entries <= eh->eh_max); ++ EXT_ASSERT(eh->eh_magic == EXT3_EXT_MAGIC); + + /* find where to start removing */ + le = ex = EXT_LAST_EXTENT(eh); + while (ex != EXT_FIRST_EXTENT(eh)) { -+ if (ex->e_block <= end) ++ if (ex->ee_block <= end) + break; + ex--; + } + -+ if (start > ex->e_block && end < ex->e_block + ex->e_num - 1) { ++ if (start > ex->ee_block && end < ex->ee_block + ex->ee_len - 1) { + /* removal of internal part of the extent requested + * tail and head must be placed in different extent + * so, we have to insert one more extent */ @@ -1519,35 +1569,34 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + } + + lu = ex; -+ while (ex >= EXT_FIRST_EXTENT(eh) && -+ ex->e_block + ex->e_num > start) { -+ ext_debug(tree, "remove ext %u:%u\n", ex->e_block, ex->e_num); ++ while (ex >= EXT_FIRST_EXTENT(eh) && ex->ee_block + ex->ee_len > start) { ++ ext_debug(tree, "remove ext %u:%u\n", ex->ee_block, ex->ee_len); + path[depth].p_ext = ex; + -+ a = ex->e_block > start ? ex->e_block : start; -+ b = ex->e_block + ex->e_num - 1 < end ? -+ ex->e_block + ex->e_num - 1 : end; ++ a = ex->ee_block > start ? ex->ee_block : start; ++ b = ex->ee_block + ex->ee_len - 1 < end ? ++ ex->ee_block + ex->ee_len - 1 : end; + + ext_debug(tree, " border %u:%u\n", a, b); + -+ if (a != ex->e_block && b != ex->e_block + ex->e_num - 1) { ++ if (a != ex->ee_block && b != ex->ee_block + ex->ee_len - 1) { + block = 0; + num = 0; + BUG(); -+ } else if (a != ex->e_block) { ++ } else if (a != ex->ee_block) { + /* remove tail of the extent */ -+ block = ex->e_block; ++ block = ex->ee_block; + num = a - block; -+ } else if (b != ex->e_block + ex->e_num - 1) { ++ } else if (b != ex->ee_block + ex->ee_len - 1) { + /* remove head of the extent */ + block = a; + num = b - a; + } else { + /* remove whole extent: excelent! */ -+ block = ex->e_block; ++ block = ex->ee_block; + num = 0; -+ EXT_ASSERT(a == ex->e_block && -+ b == ex->e_block + ex->e_num - 1); ++ EXT_ASSERT(a == ex->ee_block && ++ b == ex->ee_block + ex->ee_len - 1); + } + + if (ex == EXT_FIRST_EXTENT(eh)) @@ -1556,8 +1605,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + credits = 1; + if (correct_index) + credits += (EXT_DEPTH(tree) * EXT3_ALLOC_NEEDED) + 1; -+ if (tree->remove_extent_credits) -+ credits += tree->remove_extent_credits(tree, ex, a, b); ++ if (tree->ops->remove_extent_credits) ++ credits+=tree->ops->remove_extent_credits(tree,ex,a,b); + + handle = ext3_ext_journal_restart(handle, credits); + if (IS_ERR(handle)) { @@ -1569,48 +1618,48 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + if (err) + goto out; + -+ if (tree->remove_extent) -+ err = tree->remove_extent(tree, ex, a, b); ++ if (tree->ops->remove_extent) ++ err = tree->ops->remove_extent(tree, ex, a, b); + if (err) + goto out; + + if (num == 0) { + /* this extent is removed entirely mark slot unused */ -+ ex->e_start = 0; -+ eh->e_num--; ++ ex->ee_start = ex->ee_start_hi = 0; ++ eh->eh_entries--; + fu = ex; + } + -+ ex->e_block = block; -+ ex->e_num = num; ++ ex->ee_block = block; ++ ex->ee_len = num; + + err = ext3_ext_dirty(handle, tree, path + depth); + if (err) + goto out; + + ext_debug(tree, "new extent: %u:%u:%u\n", -+ ex->e_block, ex->e_num, ex->e_start); ++ ex->ee_block, ex->ee_len, ex->ee_start); + ex--; + } + + if (fu) { + /* reuse unused slots */ + while (lu < le) { -+ if (lu->e_start) { ++ if (lu->ee_start) { + *fu = *lu; -+ lu->e_start = 0; ++ lu->ee_start = lu->ee_start_hi = 0; + fu++; + } + lu++; + } + } + -+ if (correct_index && eh->e_num) ++ if (correct_index && eh->eh_entries) + err = ext3_ext_correct_indexes(handle, tree, path); + + /* if this leaf is free, then we should + * remove it from index block above */ -+ if (err == 0 && eh->e_num == 0 && path[depth].p_bh != NULL) ++ if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL) + err = ext3_ext_rm_idx(handle, tree, path + depth); + +out: @@ -1625,7 +1674,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + ix = EXT_LAST_INDEX(hdr); + while (ix != EXT_FIRST_INDEX(hdr)) { -+ if (ix->e_block <= block) ++ if (ix->ei_block <= block) + break; + ix--; + } @@ -1647,13 +1696,13 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + * if truncate on deeper level happened it it wasn't partial + * so we have to consider current index for truncation + */ -+ if (path->p_hdr->e_num == path->p_block) ++ if (path->p_hdr->eh_entries == path->p_block) + return 0; + return 1; +} + +int ext3_ext_remove_space(struct ext3_extents_tree *tree, -+ unsigned long start, unsigned long end) ++ unsigned long start, unsigned long end) +{ + struct inode *inode = tree->inode; + struct super_block *sb = inode->i_sb; @@ -1677,8 +1726,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + */ + path = kmalloc(sizeof(struct ext3_ext_path) * (depth + 1), GFP_KERNEL); + if (IS_ERR(path)) { -+ ext3_error(sb, "ext3_ext_remove_space", -+ "Can't allocate path array"); ++ ext3_error(sb, __FUNCTION__, "Can't allocate path array"); + ext3_journal_stop(handle, inode); + return -ENOMEM; + } @@ -1701,30 +1749,30 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + path[i].p_hdr = EXT_BLOCK_HDR(path[i].p_bh); + } + -+ EXT_ASSERT(path[i].p_hdr->e_num <= path[i].p_hdr->e_max); -+ EXT_ASSERT(path[i].p_hdr->e_magic == EXT3_EXT_MAGIC); ++ EXT_ASSERT(path[i].p_hdr->eh_entries <= path[i].p_hdr->eh_max); ++ EXT_ASSERT(path[i].p_hdr->eh_magic == EXT3_EXT_MAGIC); + + if (!path[i].p_idx) { + /* this level hasn't touched yet */ + path[i].p_idx = + ext3_ext_last_covered(path[i].p_hdr, end); -+ path[i].p_block = path[i].p_hdr->e_num + 1; ++ path[i].p_block = path[i].p_hdr->eh_entries + 1; + ext_debug(tree, "init index ptr: hdr 0x%p, num %d\n", -+ path[i].p_hdr, path[i].p_hdr->e_num); ++ path[i].p_hdr, path[i].p_hdr->eh_entries); + } else { + /* we've already was here, see at next index */ + path[i].p_idx--; + } + + ext_debug(tree, "level %d - index, first 0x%p, cur 0x%p\n", -+ i, EXT_FIRST_INDEX(path[i].p_hdr), -+ path[i].p_idx); ++ i, EXT_FIRST_INDEX(path[i].p_hdr), ++ path[i].p_idx); + if (ext3_ext_more_to_rm(path + i)) { + /* go to the next level */ + ext_debug(tree, "move to level %d (block %d)\n", -+ i + 1, path[i].p_idx->e_leaf); ++ i + 1, path[i].p_idx->ei_leaf); + memset(path + i + 1, 0, sizeof(*path)); -+ path[i+1].p_bh = sb_bread(sb, path[i].p_idx->e_leaf); ++ path[i+1].p_bh = sb_bread(sb, path[i].p_idx->ei_leaf); + if (!path[i+1].p_bh) { + /* should we reset i_size? */ + err = -EIO; @@ -1732,14 +1780,14 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + } + /* put actual number of indexes to know is this + * number got changed at the next iteration */ -+ path[i].p_block = path[i].p_hdr->e_num; ++ path[i].p_block = path[i].p_hdr->eh_entries; + i++; + } else { + /* we finish processing this index, go up */ -+ if (path[i].p_hdr->e_num == 0 && i > 0) { ++ if (path[i].p_hdr->eh_entries == 0 && i > 0) { + /* index is empty, remove it + * handle must be already prepared by the -+ * truncate_leaf() */ ++ * truncatei_leaf() */ + err = ext3_ext_rm_idx(handle, tree, path + i); + } + /* root level have p_bh == NULL, brelse() eats this */ @@ -1750,14 +1798,15 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + } + + /* TODO: flexible tree reduction should be here */ -+ if (path->p_hdr->e_num == 0) { ++ if (path->p_hdr->eh_entries == 0) { + /* + * truncate to zero freed all the tree -+ * so, we need to correct e_depth ++ * so, we need to correct eh_depth + */ + err = ext3_ext_get_access(handle, tree, path); + if (err == 0) { -+ EXT_ROOT_HDR(tree)->e_depth = 0; ++ EXT_ROOT_HDR(tree)->eh_depth = 0; ++ EXT_ROOT_HDR(tree)->eh_max = ext3_ext_space_root(tree); + err = ext3_ext_dirty(handle, tree, path); + } + } @@ -1814,22 +1863,23 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +} + +static int ext3_ext_mergable(struct ext3_extent *ex1, -+ struct ext3_extent *ex2) ++ struct ext3_extent *ex2) +{ -+ if (ex1->e_start + ex1->e_num == ex2->e_start) ++ /* FIXME: support for large fs */ ++ if (ex1->ee_start + ex1->ee_len == ex2->ee_start) + return 1; + return 0; +} + +static int +ext3_remove_blocks_credits(struct ext3_extents_tree *tree, -+ struct ext3_extent *ex, -+ unsigned long from, unsigned long to) ++ struct ext3_extent *ex, ++ unsigned long from, unsigned long to) +{ + int needed; + + /* at present, extent can't cross block group */; -+ needed = 3; /* bitmap + group desc + sb */ ++ needed = 4; /* bitmap + group desc + sb + inode */ + +#ifdef CONFIG_QUOTA + needed += 2 * EXT3_SINGLEDATA_TRANS_BLOCKS; @@ -1839,8 +1889,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + +static int +ext3_remove_blocks(struct ext3_extents_tree *tree, -+ struct ext3_extent *ex, -+ unsigned long from, unsigned long to) ++ struct ext3_extent *ex, ++ unsigned long from, unsigned long to) +{ + int needed = ext3_remove_blocks_credits(tree, ex, from, to); + handle_t *handle = ext3_journal_start(tree->inode, needed); @@ -1849,31 +1899,31 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + if (IS_ERR(handle)) + return PTR_ERR(handle); -+ if (from >= ex->e_block && to == ex->e_block + ex->e_num - 1) { ++ if (from >= ex->ee_block && to == ex->ee_block + ex->ee_len - 1) { + /* tail removal */ + unsigned long num, start; -+ num = ex->e_block + ex->e_num - from; -+ start = ex->e_start + ex->e_num - num; ++ num = ex->ee_block + ex->ee_len - from; ++ start = ex->ee_start + ex->ee_len - num; + ext_debug(tree, "free last %lu blocks starting %lu\n", -+ num, start); ++ num, start); + for (i = 0; i < num; i++) { + bh = sb_get_hash_table(tree->inode->i_sb, start + i); + ext3_forget(handle, 0, tree->inode, bh, start + i); + } + ext3_free_blocks(handle, tree->inode, start, num); -+ } else if (from == ex->e_block && to <= ex->e_block + ex->e_num - 1) { ++ } else if (from == ex->ee_block && to <= ex->ee_block + ex->ee_len - 1) { + printk("strange request: removal %lu-%lu from %u:%u\n", -+ from, to, ex->e_block, ex->e_num); ++ from, to, ex->ee_block, ex->ee_len); + } else { + printk("strange request: removal(2) %lu-%lu from %u:%u\n", -+ from, to, ex->e_block, ex->e_num); ++ from, to, ex->ee_block, ex->ee_len); + } + ext3_journal_stop(handle, tree->inode); + return 0; +} + -+static int ext3_ext_find_goal(struct inode *inode, struct ext3_ext_path *path, -+ unsigned long block) ++int ext3_ext_find_goal(struct inode *inode, struct ext3_ext_path *path, ++ unsigned long block) +{ + struct ext3_inode_info *ei = EXT3_I(inode); + unsigned long bg_start; @@ -1886,7 +1936,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + /* try to predict block placement */ + if ((ex = path[depth].p_ext)) -+ return ex->e_start + (block - ex->e_block); ++ return ex->ee_start + (block - ex->ee_block); + + /* it looks index is empty + * try to find starting from index itself */ @@ -1903,149 +1953,59 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +} + +static int ext3_new_block_cb(handle_t *handle, struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, -+ struct ext3_extent *ex, int *err) ++ struct ext3_ext_path *path, ++ struct ext3_extent *ex, int *err) +{ + struct inode *inode = tree->inode; + int newblock, goal; + + EXT_ASSERT(path); + EXT_ASSERT(ex); -+ EXT_ASSERT(ex->e_start); -+ EXT_ASSERT(ex->e_num); ++ EXT_ASSERT(ex->ee_start); ++ EXT_ASSERT(ex->ee_len); + + /* reuse block from the extent to order data/metadata */ -+ newblock = ex->e_start++; -+ ex->e_num--; -+ if (ex->e_num == 0) { -+ ex->e_num = 1; ++ newblock = ex->ee_start++; ++ ex->ee_len--; ++ if (ex->ee_len == 0) { ++ ex->ee_len = 1; + /* allocate new block for the extent */ -+ goal = ext3_ext_find_goal(inode, path, ex->e_block); -+ ex->e_start = ext3_new_block(handle, inode, goal, 0, 0, err); -+ if (ex->e_start == 0) { ++ goal = ext3_ext_find_goal(inode, path, ex->ee_block); ++ lock_kernel(); ++ ex->ee_start = ext3_new_block(handle, inode, goal, 0, 0, err); ++ ex->ee_start_hi = 0; ++ unlock_kernel(); ++ if (ex->ee_start == 0) { + /* error occured: restore old extent */ -+ ex->e_start = newblock; ++ ex->ee_start = newblock; + return 0; + } + } + return newblock; +} + -+static void ext3_init_tree_desc(struct ext3_extents_tree *tree, -+ struct inode *inode) ++static struct ext3_extents_helpers ext3_blockmap_helpers = { ++ .get_write_access = ext3_get_inode_write_access, ++ .mark_buffer_dirty = ext3_mark_buffer_dirty, ++ .mergable = ext3_ext_mergable, ++ .new_block = ext3_new_block_cb, ++ .remove_extent = ext3_remove_blocks, ++ .remove_extent_credits = ext3_remove_blocks_credits, ++}; ++ ++void ext3_init_tree_desc(struct ext3_extents_tree *tree, ++ struct inode *inode) +{ + tree->inode = inode; + tree->root = (void *) EXT3_I(inode)->i_data; -+ tree->get_write_access = ext3_get_inode_write_access; -+ tree->mark_buffer_dirty = ext3_mark_buffer_dirty; -+ tree->mergable = ext3_ext_mergable; -+ tree->new_block = ext3_new_block_cb; -+ tree->remove_extent = ext3_remove_blocks; -+ tree->remove_extent_credits = ext3_remove_blocks_credits; + tree->buffer = (void *) inode; + tree->buffer_len = sizeof(EXT3_I(inode)->i_data); -+ tree->cex = (struct ext3_extent *) &EXT3_I(inode)->i_cached_extent; ++ tree->cex = (struct ext3_ext_cache *) &EXT3_I(inode)->i_cached_extent; ++ tree->ops = &ext3_blockmap_helpers; +} + -+#if EXT3_MULTIBLOCK_ALLOCATOR -+static int -+ext3_ext_new_extent_cb(struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, -+ struct ext3_extent *newex, int exist) -+{ -+ struct inode *inode = tree->inode; -+ struct buffer_head *bh; -+ int count, err, goal; -+ unsigned long pblock; -+ unsigned long tgen; -+ loff_t new_i_size; -+ handle_t *handle; -+ int i; -+ -+ if (exist) -+ return EXT_CONTINUE; -+ -+ tgen = EXT_GENERATION(tree); -+ count = ext3_ext_calc_credits_for_insert(tree, path); -+ up_write(&EXT3_I(inode)->truncate_sem); -+ -+ handle = ext3_journal_start(inode, count + EXT3_ALLOC_NEEDED + 1); -+ if (IS_ERR(handle)) { -+ down_write(&EXT3_I(inode)->truncate_sem); -+ return PTR_ERR(handle); -+ } -+ -+ if (tgen != EXT_GENERATION(tree)) { -+ /* the tree has changed. so path can be invalid at moment */ -+ ext3_journal_stop(handle, inode); -+ down_write(&EXT3_I(inode)->truncate_sem); -+ return EXT_REPEAT; -+ } -+ -+ down_write(&EXT3_I(inode)->truncate_sem); -+ goal = ext3_ext_find_goal(inode, path, newex->e_block); -+ count = newex->e_num; -+ pblock = ext3_new_blocks(handle, inode, &count, goal, &err); -+ if (!pblock) -+ goto out; -+ EXT_ASSERT(count <= newex->e_num); -+ -+ /* insert new extent */ -+ newex->e_start = pblock; -+ newex->e_num = count; -+ err = ext3_ext_insert_extent(handle, tree, path, newex); -+ if (err) -+ goto out; -+ -+ /* block have been allocated for data, so time to drop dirty -+ * in correspondend buffer_heads to prevent corruptions */ -+ for (i = 0; i < newex->e_num; i++) { -+ bh = sb_get_hash_table(inode->i_sb, newex->e_start + i); -+ if (bh) { -+ mark_buffer_clean(bh); -+ wait_on_buffer(bh); -+ clear_bit(BH_Req, &bh->b_state); -+ __brelse(bh); -+ } -+ } -+ -+ /* correct on-disk inode size */ -+ if (newex->e_num > 0) { -+ new_i_size = (loff_t) newex->e_block + newex->e_num; -+ new_i_size = new_i_size << inode->i_blkbits; -+ if (new_i_size > EXT3_I(inode)->i_disksize) { -+ EXT3_I(inode)->i_disksize = new_i_size; -+ err = ext3_mark_inode_dirty(handle, inode); -+ } -+ } -+ -+out: -+ ext3_journal_stop(handle, inode); -+ return err; -+} -+ -+ -+int ext3_ext_allocate_nblocks(struct inode *inode, unsigned long block, -+ unsigned long num) -+{ -+ struct ext3_extents_tree tree; -+ int err; -+ -+ ext3_init_tree_desc(&tree, inode); -+ ext_debug(&tree, "blocks %lu-%lu requested for inode %u\n", -+ block, block + num,(unsigned) inode->i_ino); -+ down_write(&EXT3_I(inode)->truncate_sem); -+ err = ext3_ext_walk_space(&tree, block, num, ext3_ext_new_extent_cb); -+ ext3_ext_invalidate_cache(&tree); -+ up_write(&EXT3_I(inode)->truncate_sem); -+ -+ return err; -+} -+#endif -+ +int ext3_ext_get_block(handle_t *handle, struct inode *inode, -+ long iblock, struct buffer_head *bh_result, -+ int create, int extend_disksize) ++ long iblock, struct buffer_head *bh_result, int create) +{ + struct ext3_ext_path *path = NULL; + struct ext3_extent newex; @@ -2056,19 +2016,24 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + clear_bit(BH_New, &bh_result->b_state); + ext3_init_tree_desc(&tree, inode); + ext_debug(&tree, "block %d requested for inode %u\n", -+ (int) iblock, (unsigned) inode->i_ino); ++ (int) iblock, (unsigned) inode->i_ino); + down_write(&EXT3_I(inode)->truncate_sem); + + /* check in cache */ -+ if (ext3_ext_in_cache(&tree, iblock, &newex)) { -+ if (newex.e_start == 0xffffffff && !create) { -+ /* block isn't allocated yet and -+ * user don't want to allocate it */ -+ goto out2; -+ } else if (newex.e_start) { ++ if ((goal = ext3_ext_in_cache(&tree, iblock, &newex))) { ++ if (goal == EXT3_EXT_CACHE_GAP) { ++ if (!create) { ++ /* block isn't allocated yet and ++ * user don't want to allocate it */ ++ goto out2; ++ } ++ /* we should allocate requested block */ ++ } else if (goal == EXT3_EXT_CACHE_EXTENT) { + /* block is already allocated */ -+ newblock = iblock - newex.e_block + newex.e_start; ++ newblock = iblock - newex.ee_block + newex.ee_start; + goto out; ++ } else { ++ EXT_ASSERT(0); + } + } + @@ -2091,12 +2056,14 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + if ((ex = path[depth].p_ext)) { + /* if found exent covers block, simple return it */ -+ if (iblock >= ex->e_block && iblock < ex->e_block + ex->e_num) { -+ newblock = iblock - ex->e_block + ex->e_start; ++ if (iblock >= ex->ee_block && iblock < ex->ee_block + ex->ee_len) { ++ newblock = iblock - ex->ee_block + ex->ee_start; + ext_debug(&tree, "%d fit into %d:%d -> %d\n", -+ (int) iblock, ex->e_block, ex->e_num, -+ newblock); -+ ext3_ext_put_in_cache(&tree, ex); ++ (int) iblock, ex->ee_block, ex->ee_len, ++ newblock); ++ ext3_ext_put_in_cache(&tree, ex->ee_block, ++ ex->ee_len, ex->ee_start, ++ EXT3_EXT_CACHE_EXTENT); + goto out; + } + } @@ -2113,28 +2080,32 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + + /* allocate new block */ + goal = ext3_ext_find_goal(inode, path, iblock); ++ lock_kernel(); + newblock = ext3_new_block(handle, inode, goal, 0, 0, &err); ++ unlock_kernel(); + if (!newblock) + goto out2; + ext_debug(&tree, "allocate new block: goal %d, found %d\n", -+ goal, newblock); ++ goal, newblock); + + /* try to insert new extent into found leaf and return */ -+ newex.e_block = iblock; -+ newex.e_start = newblock; -+ newex.e_num = 1; ++ newex.ee_block = iblock; ++ newex.ee_start = newblock; ++ newex.ee_start_hi = 0; ++ newex.ee_len = 1; + err = ext3_ext_insert_extent(handle, &tree, path, &newex); + if (err) + goto out2; + -+ if (extend_disksize && inode->i_size > EXT3_I(inode)->i_disksize) ++ if (inode->i_size > EXT3_I(inode)->i_disksize) + EXT3_I(inode)->i_disksize = inode->i_size; + + /* previous routine could use block we allocated */ -+ newblock = newex.e_start; ++ newblock = newex.ee_start; + set_bit(BH_New, &bh_result->b_state); + -+ ext3_ext_put_in_cache(&tree, &newex); ++ ext3_ext_put_in_cache(&tree, newex.ee_block, newex.ee_len, ++ newex.ee_start, EXT3_EXT_CACHE_EXTENT); +out: + ext3_ext_show_leaf(&tree, path); + set_bit(BH_Mapped, &bh_result->b_state); @@ -2186,9 +2157,9 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + EXT3_I(inode)->i_disksize = inode->i_size; + ext3_mark_inode_dirty(handle, inode); + -+ last_block = (inode->i_size + sb->s_blocksize - 1) -+ >> EXT3_BLOCK_SIZE_BITS(sb); -+ err = ext3_ext_remove_space(&tree, last_block, 0xffffffff); ++ last_block = (inode->i_size + sb->s_blocksize - 1) >> ++ EXT3_BLOCK_SIZE_BITS(sb); ++ err = ext3_ext_remove_space(&tree, last_block, EXT_MAX_BLOCK); + + /* In a multi-transaction truncate, we only make the final + * transaction synchronous */ @@ -2247,13 +2218,14 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + +static int +ext3_ext_store_extent_cb(struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, -+ struct ext3_extent *newex, int exist) ++ struct ext3_ext_path *path, ++ struct ext3_ext_cache *newex) +{ + struct ext3_extent_buf *buf = (struct ext3_extent_buf *) tree->private; + -+ if (!exist) ++ if (newex->ec_type != EXT3_EXT_CACHE_EXTENT) + return EXT_CONTINUE; ++ + if (buf->err < 0) + return EXT_BREAK; + if (buf->cur - buf->buffer + sizeof(*newex) > buf->buflen) @@ -2271,14 +2243,14 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + +static int +ext3_ext_collect_stats_cb(struct ext3_extents_tree *tree, -+ struct ext3_ext_path *path, -+ struct ext3_extent *ex, int exist) ++ struct ext3_ext_path *path, ++ struct ext3_ext_cache *ex) +{ + struct ext3_extent_tree_stats *buf = + (struct ext3_extent_tree_stats *) tree->private; + int depth; + -+ if (!exist) ++ if (ex->ec_type != EXT3_EXT_CACHE_EXTENT) + return EXT_CONTINUE; + + depth = EXT_DEPTH(tree); @@ -2289,7 +2261,7 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +} + +int ext3_ext_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, -+ unsigned long arg) ++ unsigned long arg) +{ + int err = 0; + @@ -2308,8 +2280,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + buf.err = 0; + tree.private = &buf; + down_write(&EXT3_I(inode)->truncate_sem); -+ err = ext3_ext_walk_space(&tree, buf.start, 0xffffffff, -+ ext3_ext_store_extent_cb); ++ err = ext3_ext_walk_space(&tree, buf.start, EXT_MAX_BLOCK, ++ ext3_ext_store_extent_cb); + up_write(&EXT3_I(inode)->truncate_sem); + if (err == 0) + err = buf.err; @@ -2323,8 +2295,8 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c + buf.extents_num = 0; + buf.leaf_num = 0; + tree.private = &buf; -+ err = ext3_ext_walk_space(&tree, 0, 0xffffffff, -+ ext3_ext_collect_stats_cb); ++ err = ext3_ext_walk_space(&tree, 0, EXT_MAX_BLOCK, ++ ext3_ext_collect_stats_cb); + up_write(&EXT3_I(inode)->truncate_sem); + if (!err) + err = copy_to_user((void *) arg, &buf, sizeof(buf)); @@ -2346,46 +2318,62 @@ Index: linux-2.4.21-suse2/fs/ext3/extents.c +EXPORT_SYMBOL(ext3_ext_walk_space); +EXPORT_SYMBOL(ext3_ext_find_goal); +EXPORT_SYMBOL(ext3_ext_calc_credits_for_insert); -+ Index: linux-2.4.21-suse2/fs/ext3/ialloc.c =================================================================== ---- linux-2.4.21-suse2.orig/fs/ext3/ialloc.c 2004-02-05 20:42:40.000000000 +0300 -+++ linux-2.4.21-suse2/fs/ext3/ialloc.c 2004-02-05 20:42:40.000000000 +0300 -@@ -592,6 +592,10 @@ - iloc.bh = NULL; - goto fail; - } -+ if (test_opt(sb, EXTENTS)) { +--- linux-2.4.21-suse2.orig/fs/ext3/ialloc.c 2004-11-02 20:31:37.000000000 +0300 ++++ linux-2.4.21-suse2/fs/ext3/ialloc.c 2004-11-02 20:34:00.000000000 +0300 +@@ -553,7 +553,8 @@ repeat: + inode->i_blksize = PAGE_SIZE; + inode->i_blocks = 0; + inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; +- inode->u.ext3_i.i_flags = dir->u.ext3_i.i_flags & ~EXT3_INDEX_FL; ++ inode->u.ext3_i.i_flags = dir->u.ext3_i.i_flags & ++ ~(EXT3_INDEX_FL | EXT3_EXTENTS_FL); + if (S_ISLNK(mode)) + inode->u.ext3_i.i_flags &= ~(EXT3_IMMUTABLE_FL|EXT3_APPEND_FL); + #ifdef EXT3_FRAGMENTS +@@ -592,6 +592,19 @@ + iloc.bh = NULL; + goto fail; + } ++ if (test_opt(sb, EXTENTS) && S_ISREG(inode->i_mode)) { + EXT3_I(inode)->i_flags |= EXT3_EXTENTS_FL; ++ memset(&EXT3_I(inode)->i_cached_extent, 0, sizeof(__u32) * 4); + ext3_extents_initialize_blockmap(handle, inode); ++ if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_EXTENTS)) { ++ err = ext3_journal_get_write_access(handle, EXT3_SB(sb)->s_sbh); ++ if (err) goto fail; ++ EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_EXTENTS); ++ BUFFER_TRACE(EXT3_SB(sb)->s_sbh, "call ext3_journal_dirty_metadata"); ++ err = ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh); ++ } + } - err = ext3_mark_iloc_dirty(handle, inode, &iloc); - if (err) goto fail; ++ + err = ext3_mark_iloc_dirty(handle, inode, &iloc); + if (err) goto fail; Index: linux-2.4.21-suse2/fs/ext3/inode.c =================================================================== ---- linux-2.4.21-suse2.orig/fs/ext3/inode.c 2004-02-05 20:42:40.000000000 +0300 -+++ linux-2.4.21-suse2/fs/ext3/inode.c 2004-02-05 20:42:40.000000000 +0300 -@@ -853,6 +853,18 @@ +--- linux-2.4.21-suse2.orig/fs/ext3/inode.c 2004-11-02 20:31:38.000000000 +0300 ++++ linux-2.4.21-suse2/fs/ext3/inode.c 2004-11-02 20:34:00.000000000 +0300 +@@ -853,6 +853,16 @@ goto reread; } +static inline int +ext3_get_block_wrap(handle_t *handle, struct inode *inode, long block, -+ struct buffer_head *bh, int create, int extend_disksize) ++ struct buffer_head *bh, int create, int extend_disksize) +{ + if (EXT3_I(inode)->i_flags & EXT3_EXTENTS_FL) -+ return ext3_ext_get_block(handle, inode, -+ block, bh, create, -+ extend_disksize); -+ return ext3_get_block_handle(handle, inode, -+ block, bh, create, extend_disksize); ++ return ext3_ext_get_block(handle, inode, block, bh, create); ++ return ext3_get_block_handle(handle, inode, block, bh, create, ++ extend_disksize); +} + /* * The BKL is not held on entry here. */ -@@ -866,7 +878,7 @@ +@@ -866,7 +876,7 @@ handle = ext3_journal_current_handle(); J_ASSERT(handle != 0); } @@ -2394,7 +2382,7 @@ Index: linux-2.4.21-suse2/fs/ext3/inode.c bh_result, create, 1); return ret; } -@@ -893,7 +905,7 @@ +@@ -893,7 +903,7 @@ } } if (ret == 0) @@ -2403,7 +2391,7 @@ Index: linux-2.4.21-suse2/fs/ext3/inode.c bh_result, create, 0); if (ret == 0) bh_result->b_size = (1 << inode->i_blkbits); -@@ -915,7 +927,7 @@ +@@ -915,7 +925,7 @@ dummy.b_state = 0; dummy.b_blocknr = -1000; buffer_trace_init(&dummy.b_history); @@ -2412,7 +2400,7 @@ Index: linux-2.4.21-suse2/fs/ext3/inode.c if (!*errp && buffer_mapped(&dummy)) { struct buffer_head *bh; bh = sb_getblk(inode->i_sb, dummy.b_blocknr); -@@ -1502,7 +1514,7 @@ +@@ -1502,7 +1512,7 @@ * This required during truncate. We need to physically zero the tail end * of that block so it doesn't yield old data if the file is later grown. */ @@ -2421,7 +2409,7 @@ Index: linux-2.4.21-suse2/fs/ext3/inode.c struct address_space *mapping, loff_t from) { unsigned long index = from >> PAGE_CACHE_SHIFT; -@@ -1987,6 +1999,9 @@ +@@ -1988,6 +1998,9 @@ ext3_discard_prealloc(inode); @@ -2431,7 +2419,15 @@ Index: linux-2.4.21-suse2/fs/ext3/inode.c handle = start_transaction(inode); if (IS_ERR(handle)) return; /* AKPM: return what? */ -@@ -2663,6 +2678,9 @@ +@@ -2324,6 +2337,7 @@ + for (block = 0; block < EXT3_N_BLOCKS; block++) + inode->u.ext3_i.i_data[block] = iloc.raw_inode->i_block[block]; + INIT_LIST_HEAD(&inode->u.ext3_i.i_orphan); ++ memset(&EXT3_I(inode)->i_cached_extent, 0, sizeof(__u32) * 4); + + brelse (iloc.bh); + +@@ -2664,6 +2678,9 @@ int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3; int ret; @@ -2441,7 +2437,7 @@ Index: linux-2.4.21-suse2/fs/ext3/inode.c if (ext3_should_journal_data(inode)) ret = 3 * (bpp + indirects) + 2; else -@@ -3099,7 +3117,7 @@ +@@ -3100,7 +3117,7 @@ /* alloc blocks one by one */ for (i = 0; i < nblocks; i++) { @@ -2450,7 +2446,7 @@ Index: linux-2.4.21-suse2/fs/ext3/inode.c &bh_tmp, 1, 1); if (ret) break; -@@ -3175,7 +3193,7 @@ +@@ -3176,7 +3193,7 @@ if (blocks[i] != 0) continue; @@ -2461,9 +2457,9 @@ Index: linux-2.4.21-suse2/fs/ext3/inode.c "allocating block %ld\n", rc, iblock); Index: linux-2.4.21-suse2/fs/ext3/Makefile =================================================================== ---- linux-2.4.21-suse2.orig/fs/ext3/Makefile 2004-02-05 20:42:39.000000000 +0300 -+++ linux-2.4.21-suse2/fs/ext3/Makefile 2004-02-05 20:43:47.000000000 +0300 -@@ -12,7 +12,9 @@ +--- linux-2.4.21-suse2.orig/fs/ext3/Makefile 2004-11-02 20:31:33.000000000 +0300 ++++ linux-2.4.21-suse2/fs/ext3/Makefile 2004-11-02 20:31:39.000000000 +0300 +@@ -12,7 +12,10 @@ export-objs := ext3-exports.o obj-y := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o iopen.o \ @@ -2471,33 +2467,36 @@ Index: linux-2.4.21-suse2/fs/ext3/Makefile + ioctl.o namei.o super.o symlink.o hash.o ext3-exports.o \ + extents.o +export-objs += extents.o ++ obj-m := $(O_TARGET) export-objs += xattr.o Index: linux-2.4.21-suse2/fs/ext3/super.c =================================================================== ---- linux-2.4.21-suse2.orig/fs/ext3/super.c 2004-02-05 20:42:40.000000000 +0300 -+++ linux-2.4.21-suse2/fs/ext3/super.c 2004-02-05 20:42:40.000000000 +0300 -@@ -624,6 +624,7 @@ - int i; - +--- linux-2.4.21-suse2.orig/fs/ext3/super.c 2005-04-04 05:44:58.000000000 -0600 ++++ linux-2.4.21-suse2/fs/ext3/super.c 2005-04-04 05:45:43.000000000 -0600 +@@ -532,6 +532,7 @@ + #ifdef EXT3_DELETE_THREAD J_ASSERT(sbi->s_delete_inodes == 0); + #endif + ext3_ext_release(sb); ext3_xattr_put_super(sb); journal_destroy(sbi->s_journal); if (!(sb->s_flags & MS_RDONLY)) { -@@ -829,6 +830,10 @@ +@@ -733,6 +734,12 @@ return 0; } } + else if (!strcmp (this_char, "extents")) + set_opt (*mount_options, EXTENTS); ++ else if (!strcmp (this_char, "noextents")) ++ clear_opt (*mount_options, EXTENTS); + else if (!strcmp (this_char, "extdebug")) + set_opt (*mount_options, EXTDEBUG); else if (!strcmp (this_char, "grpid") || !strcmp (this_char, "bsdgroups")) set_opt (*mount_options, GRPID); -@@ -1523,6 +1528,8 @@ +@@ -1428,6 +1433,8 @@ test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA ? "ordered": "writeback"); @@ -2508,8 +2507,8 @@ Index: linux-2.4.21-suse2/fs/ext3/super.c failed_mount3: Index: linux-2.4.21-suse2/fs/ext3/ioctl.c =================================================================== ---- linux-2.4.21-suse2.orig/fs/ext3/ioctl.c 2004-02-05 20:42:39.000000000 +0300 -+++ linux-2.4.21-suse2/fs/ext3/ioctl.c 2004-02-05 20:42:40.000000000 +0300 +--- linux-2.4.21-suse2.orig/fs/ext3/ioctl.c 2004-11-02 20:31:32.000000000 +0300 ++++ linux-2.4.21-suse2/fs/ext3/ioctl.c 2004-11-02 20:31:39.000000000 +0300 @@ -174,6 +174,10 @@ return ret; } @@ -2523,65 +2522,86 @@ Index: linux-2.4.21-suse2/fs/ext3/ioctl.c } Index: linux-2.4.21-suse2/include/linux/ext3_fs.h =================================================================== ---- linux-2.4.21-suse2.orig/include/linux/ext3_fs.h 2004-02-05 20:42:40.000000000 +0300 -+++ linux-2.4.21-suse2/include/linux/ext3_fs.h 2004-02-05 20:42:40.000000000 +0300 -@@ -184,6 +184,7 @@ +--- linux-2.4.21-suse2.orig/include/linux/ext3_fs.h 2004-11-02 20:31:37.000000000 +0300 ++++ linux-2.4.21-suse2/include/linux/ext3_fs.h 2004-11-02 20:31:39.000000000 +0300 +@@ -184,8 +184,9 @@ #define EXT3_IMAGIC_FL 0x00002000 /* AFS directory */ #define EXT3_JOURNAL_DATA_FL 0x00004000 /* file data should be journaled */ #define EXT3_RESERVED_FL 0x80000000 /* reserved for ext3 lib */ +#define EXT3_EXTENTS_FL 0x00080000 /* Inode uses extents */ - #define EXT3_FL_USER_VISIBLE 0x00005FFF /* User visible flags */ +-#define EXT3_FL_USER_VISIBLE 0x00005FFF /* User visible flags */ ++#define EXT3_FL_USER_VISIBLE 0x00085FFF /* User visible flags */ #define EXT3_FL_USER_MODIFIABLE 0x000000FF /* User modifiable flags */ + + /* @@ -208,6 +209,9 @@ #ifdef CONFIG_JBD_DEBUG #define EXT3_IOC_WAIT_FOR_READONLY _IOR('f', 99, long) #endif -+#define EXT3_IOC_GET_EXTENTS _IOR('f', 5, long) -+#define EXT3_IOC_GET_TREE_DEPTH _IOR('f', 6, long) -+#define EXT3_IOC_GET_TREE_STATS _IOR('f', 7, long) ++#define EXT3_IOC_GET_EXTENTS _IOR('f', 7, long) ++#define EXT3_IOC_GET_TREE_DEPTH _IOR('f', 8, long) ++#define EXT3_IOC_GET_TREE_STATS _IOR('f', 9, long) /* * Structure of an inode on the disk @@ -328,6 +332,8 @@ #define EXT3_MOUNT_ASYNCDEL 0x20000 /* Delayed deletion */ - #define EXT3_MOUNT_IOPEN 0x40000 /* Allow access via iopen */ - #define EXT3_MOUNT_IOPEN_NOPRIV 0x80000 /* Make iopen world-readable */ -+#define EXT3_MOUNT_EXTENTS 0x100000/* Extents support */ -+#define EXT3_MOUNT_EXTDEBUG 0x200000/* Extents debug */ + #define EXT3_MOUNT_IOPEN 0x80000 /* Allow access via iopen */ + #define EXT3_MOUNT_IOPEN_NOPRIV 0x100000/* Make iopen world-readable */ ++#define EXT3_MOUNT_EXTENTS 0x200000/* Extents support */ ++#define EXT3_MOUNT_EXTDEBUG 0x400000/* Extents debug */ /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */ #ifndef _LINUX_EXT2_FS_H -@@ -689,6 +695,7 @@ +@@ -504,10 +510,12 @@ + #define EXT3_FEATURE_INCOMPAT_FILETYPE 0x0002 + #define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004 /* Needs recovery */ + #define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 /* Journal device */ ++#define EXT3_FEATURE_INCOMPAT_EXTENTS 0x0040 /* extents support */ + + #define EXT3_FEATURE_COMPAT_SUPP EXT2_FEATURE_COMPAT_EXT_ATTR + #define EXT3_FEATURE_INCOMPAT_SUPP (EXT3_FEATURE_INCOMPAT_FILETYPE| \ +- EXT3_FEATURE_INCOMPAT_RECOVER) ++ EXT3_FEATURE_INCOMPAT_RECOVER| \ ++ EXT3_FEATURE_INCOMPAT_EXTENTS) + #define EXT3_FEATURE_RO_COMPAT_SUPP (EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER| \ + EXT3_FEATURE_RO_COMPAT_LARGE_FILE| \ + EXT3_FEATURE_RO_COMPAT_BTREE_DIR) +@@ -689,6 +697,8 @@ extern unsigned long ext3_count_free (struct buffer_head *, unsigned); /* inode.c */ +extern int ext3_block_truncate_page(handle_t *, struct address_space *, loff_t); ++extern int ext3_writepage_trans_blocks(struct inode *inode); extern int ext3_forget(handle_t *, int, struct inode *, struct buffer_head *, int); extern struct buffer_head * ext3_getblk (handle_t *, struct inode *, long, int, int *); extern struct buffer_head * ext3_bread (handle_t *, struct inode *, int, int, int *); -@@ -770,6 +777,14 @@ +@@ -770,6 +779,16 @@ extern struct inode_operations ext3_symlink_inode_operations; extern struct inode_operations ext3_fast_symlink_inode_operations; +/* extents.c */ +extern int ext3_ext_writepage_trans_blocks(struct inode *, int); +extern int ext3_ext_get_block(handle_t *, struct inode *, long, -+ struct buffer_head *, int, int); ++ struct buffer_head *, int); +extern void ext3_ext_truncate(struct inode *); +extern void ext3_ext_init(struct super_block *); +extern void ext3_ext_release(struct super_block *); +extern void ext3_extents_initialize_blockmap(handle_t *, struct inode *); ++extern int ext3_ext_ioctl(struct inode *inode, struct file *filp, ++ unsigned int cmd, unsigned long arg); #endif /* __KERNEL__ */ Index: linux-2.4.21-suse2/include/linux/ext3_extents.h =================================================================== --- linux-2.4.21-suse2.orig/include/linux/ext3_extents.h 2003-01-30 13:24:37.000000000 +0300 -+++ linux-2.4.21-suse2/include/linux/ext3_extents.h 2004-02-05 20:42:40.000000000 +0300 -@@ -0,0 +1,216 @@ ++++ linux-2.4.21-suse2/include/linux/ext3_extents.h 2004-11-02 20:34:00.000000000 +0300 +@@ -0,0 +1,261 @@ +/* -+ * Copyright (C) 2003 Alex Tomas ++ * Copyright (c) 2003, Cluster File Systems, Inc, info@clusterfs.com ++ * Written by Alex Tomas + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as @@ -2618,9 +2638,9 @@ Index: linux-2.4.21-suse2/include/linux/ext3_extents.h + * if EXT_DEBUG is defined you can use 'extdebug' mount option + * to get lots of info what's going on + */ -+#define EXT_DEBUG ++#define EXT_DEBUG_ +#ifdef EXT_DEBUG -+#define ext_debug(tree,fmt,a...) \ ++#define ext_debug(tree,fmt,a...) \ +do { \ + if (test_opt((tree)->inode->i_sb, EXTDEBUG)) \ + printk(fmt, ##a); \ @@ -2650,9 +2670,10 @@ Index: linux-2.4.21-suse2/include/linux/ext3_extents.h + * it's used at the bottom of the tree + */ +struct ext3_extent { -+ __u32 e_block; /* first logical block extent covers */ -+ __u32 e_start; /* first physical block extents lives */ -+ __u32 e_num; /* number of blocks covered by extent */ ++ __u32 ee_block; /* first logical block extent covers */ ++ __u16 ee_len; /* number of blocks covered by extent */ ++ __u16 ee_start_hi; /* high 16 bits of physical block */ ++ __u32 ee_start; /* low 32 bigs of physical block */ +}; + +/* @@ -2660,23 +2681,25 @@ Index: linux-2.4.21-suse2/include/linux/ext3_extents.h + * it's used at all the levels, but the bottom + */ +struct ext3_extent_idx { -+ __u32 e_block; /* index covers logical blocks from 'block' */ -+ __u32 e_leaf; /* pointer to the physical block of the next * ++ __u32 ei_block; /* index covers logical blocks from 'block' */ ++ __u32 ei_leaf; /* pointer to the physical block of the next * + * level. leaf or next index could bet here */ ++ __u16 ei_leaf_hi; /* high 16 bits of physical block */ ++ __u16 ei_unused; +}; + +/* + * each block (leaves and indexes), even inode-stored has header + */ +struct ext3_extent_header { -+ __u16 e_magic; /* probably will support different formats */ -+ __u16 e_num; /* number of valid entries */ -+ __u16 e_max; /* capacity of store in entries */ -+ __u16 e_depth; /* has tree real underlaying blocks? */ -+ __u32 e_generation; /* generation of the tree */ ++ __u16 eh_magic; /* probably will support different formats */ ++ __u16 eh_entries; /* number of valid entries */ ++ __u16 eh_max; /* capacity of store in entries */ ++ __u16 eh_depth; /* has tree real underlaying blocks? */ ++ __u32 eh_generation; /* flags(8 bits) | generation of the tree */ +}; + -+#define EXT3_EXT_MAGIC 0xf301 ++#define EXT3_EXT_MAGIC 0xf30a + +/* + * array of ext3_ext_path contains path to some extent @@ -2696,30 +2719,48 @@ Index: linux-2.4.21-suse2/include/linux/ext3_extents.h + * structure for external API + */ + ++/* ++ * storage for cached extent ++ */ ++struct ext3_ext_cache { ++ __u32 ec_start; ++ __u32 ec_block; ++ __u32 ec_len; ++ __u32 ec_type; ++}; ++ ++#define EXT3_EXT_CACHE_NO 0 ++#define EXT3_EXT_CACHE_GAP 1 ++#define EXT3_EXT_CACHE_EXTENT 2 + +/* + * ext3_extents_tree is used to pass initial information + * to top-level extents API + */ ++struct ext3_extents_helpers; +struct ext3_extents_tree { + struct inode *inode; /* inode which tree belongs to */ + void *root; /* ptr to data top of tree resides at */ + void *buffer; /* will be passed as arg to ^^ routines */ + int buffer_len; + void *private; -+ struct ext3_extent *cex;/* last found extent */ ++ struct ext3_ext_cache *cex;/* last found extent */ ++ struct ext3_extents_helpers *ops; ++}; ++ ++struct ext3_extents_helpers { + int (*get_write_access)(handle_t *h, void *buffer); + int (*mark_buffer_dirty)(handle_t *h, void *buffer); + int (*mergable)(struct ext3_extent *ex1, struct ext3_extent *ex2); + int (*remove_extent_credits)(struct ext3_extents_tree *, -+ struct ext3_extent *, unsigned long, -+ unsigned long); ++ struct ext3_extent *, unsigned long, ++ unsigned long); + int (*remove_extent)(struct ext3_extents_tree *, -+ struct ext3_extent *, unsigned long, -+ unsigned long); ++ struct ext3_extent *, unsigned long, ++ unsigned long); + int (*new_block)(handle_t *, struct ext3_extents_tree *, -+ struct ext3_ext_path *, struct ext3_extent *, -+ int *); ++ struct ext3_ext_path *, struct ext3_extent *, ++ int *); +}; + +/* @@ -2729,14 +2770,17 @@ Index: linux-2.4.21-suse2/include/linux/ext3_extents.h + * callback must return valid extent (passed or newly created) + */ +typedef int (*ext_prepare_callback)(struct ext3_extents_tree *, -+ struct ext3_ext_path *, -+ struct ext3_extent *, int); ++ struct ext3_ext_path *, ++ struct ext3_ext_cache *); + +#define EXT_CONTINUE 0 +#define EXT_BREAK 1 +#define EXT_REPEAT 2 + + ++#define EXT_MAX_BLOCK 0xffffffff ++ ++ +#define EXT_FIRST_EXTENT(__hdr__) \ + ((struct ext3_extent *) (((char *) (__hdr__)) + \ + sizeof(struct ext3_extent_header))) @@ -2744,28 +2788,40 @@ Index: linux-2.4.21-suse2/include/linux/ext3_extents.h + ((struct ext3_extent_idx *) (((char *) (__hdr__)) + \ + sizeof(struct ext3_extent_header))) +#define EXT_HAS_FREE_INDEX(__path__) \ -+ ((__path__)->p_hdr->e_num < (__path__)->p_hdr->e_max) ++ ((__path__)->p_hdr->eh_entries < (__path__)->p_hdr->eh_max) +#define EXT_LAST_EXTENT(__hdr__) \ -+ (EXT_FIRST_EXTENT((__hdr__)) + (__hdr__)->e_num - 1) ++ (EXT_FIRST_EXTENT((__hdr__)) + (__hdr__)->eh_entries - 1) +#define EXT_LAST_INDEX(__hdr__) \ -+ (EXT_FIRST_INDEX((__hdr__)) + (__hdr__)->e_num - 1) ++ (EXT_FIRST_INDEX((__hdr__)) + (__hdr__)->eh_entries - 1) +#define EXT_MAX_EXTENT(__hdr__) \ -+ (EXT_FIRST_EXTENT((__hdr__)) + (__hdr__)->e_max - 1) ++ (EXT_FIRST_EXTENT((__hdr__)) + (__hdr__)->eh_max - 1) +#define EXT_MAX_INDEX(__hdr__) \ -+ (EXT_FIRST_INDEX((__hdr__)) + (__hdr__)->e_max - 1) -+ -+#define EXT_ROOT_HDR(tree) \ -+ ((struct ext3_extent_header *) (tree)->root) -+#define EXT_BLOCK_HDR(bh) \ -+ ((struct ext3_extent_header *) (bh)->b_data) -+#define EXT_DEPTH(_t_) \ -+ (((struct ext3_extent_header *)((_t_)->root))->e_depth) -+#define EXT_GENERATION(_t_) \ -+ (((struct ext3_extent_header *)((_t_)->root))->e_generation) ++ (EXT_FIRST_INDEX((__hdr__)) + (__hdr__)->eh_max - 1) ++#define EXT_HDR_GEN(__hdr__) ((__hdr__)->eh_generation & 0x00ffffff) ++#define EXT_FLAGS(__hdr__) ((__hdr__)->eh_generation >> 24) ++#define EXT_FLAGS_CLR_UNKNOWN 0x7 /* Flags cleared on modification */ + ++#define EXT_BLOCK_HDR(__bh__) ((struct ext3_extent_header *)(__bh__)->b_data) ++#define EXT_ROOT_HDR(__tree__) ((struct ext3_extent_header *)(__tree__)->root) ++#define EXT_DEPTH(__tree__) (EXT_ROOT_HDR(__tree__)->eh_depth) ++#define EXT_GENERATION(__tree__) EXT_HDR_GEN(EXT_ROOT_HDR(__tree__)) + +#define EXT_ASSERT(__x__) if (!(__x__)) BUG(); + ++#define EXT_CHECK_PATH(tree,path) \ ++{ \ ++ int depth = EXT_DEPTH(tree); \ ++ BUG_ON((unsigned long) (path) < __PAGE_OFFSET); \ ++ BUG_ON((unsigned long) (path)[depth].p_idx < \ ++ __PAGE_OFFSET && (path)[depth].p_idx != NULL); \ ++ BUG_ON((unsigned long) (path)[depth].p_ext < \ ++ __PAGE_OFFSET && (path)[depth].p_ext != NULL); \ ++ BUG_ON((unsigned long) (path)[depth].p_hdr < __PAGE_OFFSET); \ ++ BUG_ON((unsigned long) (path)[depth].p_bh < __PAGE_OFFSET \ ++ && depth != 0); \ ++ BUG_ON((path)[0].p_depth != depth); \ ++} ++ + +/* + * this structure is used to gather extents from the tree via ioctl @@ -2787,6 +2843,7 @@ Index: linux-2.4.21-suse2/include/linux/ext3_extents.h + int leaf_num; +}; + ++extern void ext3_init_tree_desc(struct ext3_extents_tree *, struct inode *); +extern int ext3_extent_tree_init(handle_t *, struct ext3_extents_tree *); +extern int ext3_ext_calc_credits_for_insert(struct ext3_extents_tree *, struct ext3_ext_path *); +extern int ext3_ext_insert_extent(handle_t *, struct ext3_extents_tree *, struct ext3_ext_path *, struct ext3_extent *); @@ -2794,18 +2851,25 @@ Index: linux-2.4.21-suse2/include/linux/ext3_extents.h +extern int ext3_ext_remove_space(struct ext3_extents_tree *, unsigned long, unsigned long); +extern struct ext3_ext_path * ext3_ext_find_extent(struct ext3_extents_tree *, int, struct ext3_ext_path *); + -+#endif /* _LINUX_EXT3_EXTENTS */ ++static inline void ++ext3_ext_invalidate_cache(struct ext3_extents_tree *tree) ++{ ++ if (tree->cex) ++ tree->cex->ec_type = EXT3_EXT_CACHE_NO; ++} + ++ ++#endif /* _LINUX_EXT3_EXTENTS */ Index: linux-2.4.21-suse2/include/linux/ext3_fs_i.h =================================================================== ---- linux-2.4.21-suse2.orig/include/linux/ext3_fs_i.h 2004-02-05 20:42:40.000000000 +0300 -+++ linux-2.4.21-suse2/include/linux/ext3_fs_i.h 2004-02-05 20:47:04.000000000 +0300 +--- linux-2.4.21-suse2.orig/include/linux/ext3_fs_i.h 2004-11-02 20:31:37.000000000 +0300 ++++ linux-2.4.21-suse2/include/linux/ext3_fs_i.h 2004-11-02 20:45:16.000000000 +0300 @@ -90,6 +90,8 @@ * by other means, so we have truncate_sem. */ struct rw_semaphore truncate_sem; + -+ __u32 i_cached_extent[3]; ++ __u32 i_cached_extent[4]; }; #endif /* _LINUX_EXT3_FS_I */