diff --git a/fs/tux3/Makefile b/fs/tux3/Makefile
index 93229a1..f5ceaea 100644
--- a/fs/tux3/Makefile
+++ b/fs/tux3/Makefile
@@ -7,7 +7,7 @@
 	make -C $(LINUX) M=`pwd` CONFIG_TUX3=m clean
 else
 obj-$(CONFIG_TUX3) += tux3.o
-tux3-objs += balloc.o btree.o buffer.o commit.o dir.o dleaf.o dleaf2.o \
+tux3-objs += balloc.o btree.o buffer.o commit.o dir.o dleaf.o \
 	filemap.o iattr.o ileaf.o inode.o log.o namei.o orphan.o replay.o \
 	super.o utility.o writeback.o xattr.o
 EXTRA_CFLAGS += -Werror -std=gnu99 -Wno-declaration-after-statement
diff --git a/fs/tux3/dleaf2.c b/fs/tux3/dleaf.c
similarity index 99%
rename from fs/tux3/dleaf2.c
rename to fs/tux3/dleaf.c
index 6d0e32c..cbd32bf 100644
--- a/fs/tux3/dleaf2.c
+++ b/fs/tux3/dleaf.c
@@ -29,7 +29,7 @@
  */
 
 #include "tux3.h"
-#include "dleaf2.h"
+#include "dleaf.h"
 
 /*
  * The uptag is for filesystem integrity checking and corruption
diff --git a/fs/tux3/dleaf.h b/fs/tux3/dleaf.h
index e0dd69f..ffbc2fa 100644
--- a/fs/tux3/dleaf.h
+++ b/fs/tux3/dleaf.h
@@ -1,136 +1,30 @@
-#ifndef TUX3_DLEAF_H
-#define TUX3_DLEAF_H
+#ifndef TUX3_DLEAF2_H
+#define TUX3_DLEAF2_H
 
-/* version:10, count:6, block:48 */
-struct diskextent { __be64 block_count_version; };
-#define MAX_GROUP_ENTRIES 255
-/* count:8, keyhi:24 */
-struct group { __be32 count_and_keyhi; };
-/* limit:8, keylo:24 */
-struct entry { __be32 limit_and_keylo; };
-struct dleaf { __be16 magic, groups, free, used; struct diskextent table[]; };
+struct dleaf_req {
+	struct btree_key_range key;	/* index and count */
 
-/* Maximum size of one extent on dleaf. */
-#define DLEAF_MAX_EXTENT_SIZE \
-	(sizeof(struct group)+sizeof(struct entry)+sizeof(struct diskextent))
+	int seg_cnt;			/* How many segs are available */
+	int seg_max;			/* Max size of seg[] */
+	struct block_segment *seg;	/* Pointer to seg[] */
 
-struct dwalk {
-	struct dleaf *leaf;
-	struct group *group, *gstop, *gdict;
-	struct entry *entry, *estop;
-	struct diskextent *exbase, *extent, *exstop;
-	struct {
-		struct group group;
-		struct entry entry;
-		int used, free, groups;
-	} mock;
+	int seg_idx;			/* use by dleaf2_write() internally */
+	int overwrite;
+
+	/* Callback to allocate blocks to ->seg for write */
+	int (*seg_find)(struct btree *, struct dleaf_req *, int, unsigned,
+			unsigned *);
+	int (*seg_alloc)(struct btree *, struct dleaf_req *, int);
+	void (*seg_free)(struct btree *, block_t, unsigned);
 };
 
-/* group wrappers */
-
-static inline struct group make_group(tuxkey_t keyhi, unsigned count)
+static inline unsigned seg_total_count(struct block_segment *seg, int nr_segs)
 {
-	return (struct group){ cpu_to_be32(keyhi | (count << 24)) };
+	unsigned total = 0;
+	int i;
+	for (i = 0; i < nr_segs; i++)
+		total += seg[i].count;
+	return total;
 }
 
-static inline unsigned group_keyhi(struct group *group)
-{
-	return be32_to_cpup((__be32 *)group) & 0xffffff;
-}
-
-static inline unsigned group_count(struct group *group)
-{
-	return *(unsigned char *)group;
-}
-
-static inline void set_group_count(struct group *group, int n)
-{
-	*(unsigned char *)group = n;
-}
-
-static inline void inc_group_count(struct group *group, int n)
-{
-	*(unsigned char *)group += n;
-}
-
-/* entry wrappers */
-
-static inline struct entry make_entry(tuxkey_t keylo, unsigned limit)
-{
-	return (struct entry){ cpu_to_be32(keylo | (limit << 24)) };
-}
-
-static inline unsigned entry_keylo(struct entry *entry)
-{
-	return be32_to_cpup((__be32 *)entry) & ~(-1 << 24);
-}
-
-static inline unsigned entry_limit(struct entry *entry)
-{
-	return *(unsigned char *)entry;
-}
-
-static inline void inc_entry_limit(struct entry *entry, int n)
-{
-	*(unsigned char *)entry += n;
-}
-
-/* extent wrappers */
-
-static inline struct diskextent make_extent(block_t block, unsigned count)
-{
-	assert(block < (1ULL << 48) && count - 1 < (1 << 6));
-	return (struct diskextent){ cpu_to_be64(((u64)(count - 1) << 48) | block) };
-}
-
-static inline block_t extent_block(struct diskextent extent)
-{
-	return be64_to_cpup((__be64 *)&extent) & ~(-1LL << 48);
-}
-
-static inline unsigned extent_count(struct diskextent extent)
-{
-	return ((be64_to_cpup((__be64 *)&extent) >> 48) & 0x3f) + 1;
-}
-
-static inline unsigned extent_version(struct diskextent extent)
-{
-	return be64_to_cpu(*(__be64 *)&extent) >> 54;
-}
-
-/* dleaf wrappers */
-
-static inline unsigned dleaf_groups(struct dleaf *leaf)
-{
-	return be16_to_cpu(leaf->groups);
-}
-
-static inline void set_dleaf_groups(struct dleaf *leaf, int n)
-{
-	leaf->groups = cpu_to_be16(n);
-}
-
-static inline void inc_dleaf_groups(struct dleaf *leaf, int n)
-{
-	be16_add_cpu(&leaf->groups, n);
-}
-
-int dleaf_init(struct btree *btree, void *leaf);
-unsigned dleaf_free(struct btree *btree, void *leaf);
-void dleaf_dump(struct btree *btree, void *vleaf);
-int dleaf_merge(struct btree *btree, void *vinto, void *vfrom);
-extern struct btree_ops dtree1_ops;
-
-void dwalk_redirect(struct dwalk *walk, struct dleaf *src, struct dleaf *dst);
-int dwalk_end(struct dwalk *walk);
-block_t dwalk_block(struct dwalk *walk);
-unsigned dwalk_count(struct dwalk *walk);
-tuxkey_t dwalk_index(struct dwalk *walk);
-int dwalk_next(struct dwalk *walk);
-int dwalk_back(struct dwalk *walk);
-int dwalk_probe(struct dleaf *leaf, unsigned blocksize, struct dwalk *walk, tuxkey_t key);
-int dwalk_mock(struct dwalk *walk, tuxkey_t index, struct diskextent extent);
-void dwalk_copy(struct dwalk *walk, struct dleaf *dest);
-void dwalk_chop(struct dwalk *walk);
-int dwalk_add(struct dwalk *walk, tuxkey_t index, struct diskextent extent);
-#endif /* !TUX3_DLEAF_H */
+#endif /* !TUX3_DLEAF2_H */
diff --git a/fs/tux3/dleaf2.h b/fs/tux3/dleaf2.h
deleted file mode 100644
index ffbc2fa..0000000
--- a/fs/tux3/dleaf2.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef TUX3_DLEAF2_H
-#define TUX3_DLEAF2_H
-
-struct dleaf_req {
-	struct btree_key_range key;	/* index and count */
-
-	int seg_cnt;			/* How many segs are available */
-	int seg_max;			/* Max size of seg[] */
-	struct block_segment *seg;	/* Pointer to seg[] */
-
-	int seg_idx;			/* use by dleaf2_write() internally */
-	int overwrite;
-
-	/* Callback to allocate blocks to ->seg for write */
-	int (*seg_find)(struct btree *, struct dleaf_req *, int, unsigned,
-			unsigned *);
-	int (*seg_alloc)(struct btree *, struct dleaf_req *, int);
-	void (*seg_free)(struct btree *, block_t, unsigned);
-};
-
-static inline unsigned seg_total_count(struct block_segment *seg, int nr_segs)
-{
-	unsigned total = 0;
-	int i;
-	for (i = 0; i < nr_segs; i++)
-		total += seg[i].count;
-	return total;
-}
-
-#endif /* !TUX3_DLEAF2_H */
diff --git a/fs/tux3/filemap.c b/fs/tux3/filemap.c
index 678c217..34407ba 100644
--- a/fs/tux3/filemap.c
+++ b/fs/tux3/filemap.c
@@ -45,7 +45,7 @@
  */
 
 #include "tux3.h"
-#include "dleaf2.h"
+#include "dleaf.h"
 
 #ifndef trace
 #define trace trace_on
@@ -89,280 +89,6 @@
 	return 0;
 }
 
-/* map_region() by using dleaf1 */
-static int map_region1(struct inode *inode, block_t start, unsigned count,
-		       struct block_segment seg[], unsigned seg_max,
-		       enum map_mode mode)
-{
-	struct sb *sb = tux_sb(inode->i_sb);
-	struct btree *btree = &tux_inode(inode)->btree;
-	struct cursor *cursor = NULL;
-	int err, segs = 0;
-
-	assert(seg_max > 0);
-
-	/*
-	 * bitmap enters here recursively.
-	 *
-	 * tux3_flush_inode_internal() (flush bitmap)
-	 *   flush_list()
-	 *     map_region() (for flush)
-	 *       balloc()
-	 *         read bitmap
-	 *           map_region() (for read)
-	 *
-	 * But bitmap is used (read/write) only from backend.
-	 * So, no need to lock.
-	 */
-	if (tux_inode(inode)->inum != TUX_BITMAP_INO) {
-		if (mode == MAP_READ)
-			down_read(&btree->lock);
-		else {
-			/* If write, must be backend */
-			assert(tux3_under_backend(sb));
-			down_write(&btree->lock);
-		}
-	} else {
-		/* If bitmap, must be backend */
-		assert(tux3_under_backend(sb));
-	}
-
-	if (!has_root(btree) && mode != MAP_READ) {
-		/*
-		 * Allocate empty btree if this btree doesn't have it yet.
-		 * FIXME: this should be merged to insert_leaf() or something?
-		 */
-		err = alloc_empty_btree(btree);
-		if (err) {
-			segs = err;
-			goto out_unlock;
-		}
-	}
-
-	/* dwalk_end(walk) is true with this. */
-	struct dwalk *walk = &(struct dwalk){ };
-	struct dleaf *leaf = NULL;
-	if (has_root(btree)) {
-		cursor = alloc_cursor(btree, 1); /* allows for depth increase */
-		if (!cursor) {
-			segs = -ENOMEM;
-			goto out_unlock;
-		}
-
-		if ((err = btree_probe(cursor, start))) {
-			segs = err;
-			goto out_unlock;
-		}
-		leaf = bufdata(cursor_leafbuf(cursor));
-		dleaf_dump(btree, leaf);
-		dwalk_probe(leaf, sb->blocksize, walk, start);
-	} else {
-		assert(mode == MAP_READ);
-		/* btree doesn't have root yet */
-	}
-
-	block_t limit = start + count;
-	if (cursor) {
-		assert(start >= cursor_this_key(cursor));
-		/* do not overlap next leaf */
-		if (limit > cursor_next_key(cursor))
-			limit = cursor_next_key(cursor);
-	}
-	trace("--- index %Lx, limit %Lx ---", start, limit);
-
-	block_t index = start, seg_start, block;
-	struct dwalk headwalk = *walk;
-	if (!dwalk_end(walk) && dwalk_index(walk) < start)
-		seg_start = dwalk_index(walk);
-	else
-		seg_start = index;
-	while (index < limit && segs < seg_max) {
-		block_t ex_index;
-		if (!dwalk_end(walk))
-			ex_index = dwalk_index(walk);
-		else
-			ex_index = limit;
-
-		if (index < ex_index) {
-			/* There is hole */
-			ex_index = min(ex_index, limit);
-			unsigned gap = ex_index - index;
-			index = ex_index;
-			seg[segs++] = (struct block_segment){
-				.count = gap,
-				.state = BLOCK_SEG_HOLE,
-			};
-		} else {
-			block = dwalk_block(walk);
-			count = dwalk_count(walk);
-			trace("emit %Lx/%x", block, count);
-			seg[segs++] = (struct block_segment){
-				.block = block,
-				.count = count,
-			};
-			index = ex_index + count;
-			dwalk_next(walk);
-		}
-	}
-	assert(segs);
-	unsigned below = start - seg_start, above = index - min(index, limit);
-	seg[0].block += below;
-	seg[0].count -= below;
-	seg[segs - 1].count -= above;
-
-	if (mode == MAP_READ)
-		goto out_release;
-
-	/* Save blocks before change seg[] for below or above. */
-	block_t below_block, above_block;
-	below_block = seg[0].block - below;
-	above_block = seg[segs - 1].block + seg[segs - 1].count;
-	if (mode == MAP_REDIRECT) {
-		/* Change the seg[] to redirect this region as one extent */
-		count = 0;
-		for (int i = 0; i < segs; i++) {
-			/* Logging overwritten extents as free */
-			if (seg[i].state != BLOCK_SEG_HOLE)
-				map_bfree(inode, seg[i].block, seg[i].count);
-			count += seg[i].count;
-		}
-		segs = 1;
-		seg[0].block = 0;
-		seg[0].count = count;
-		seg[0].state = BLOCK_SEG_HOLE;
-	}
-	for (int i = 0; i < segs; i++) {
-		int newsegs;
-		if (seg[i].state != BLOCK_SEG_HOLE)
-			continue;
-
-		count = seg[i].count;
-		err = balloc_segs(sb, &seg[i], 1, &newsegs, &count);
-		if (!err && count != 0) {
-			/* FIXME: should handle partial allocation */
-			err = -ENOSPC;
-		}
-		if (err) {
-			/*
-			 * Out of space on file data allocation.  It happens.  Tread
-			 * carefully.  We have not stored anything in the btree yet,
-			 * so we free what we allocated so far.  We need to leave the
-			 * user with a nice ENOSPC return and all metadata consistent
-			 * on disk.  We better have reserved everything we need for
-			 * metadata, just giving up is not an option.
-			 */
-			/*
-			 * Alternatively, we can go ahead and try to record just what
-			 * we successfully allocated, then if the update fails on no
-			 * space for btree splits, free just the blocks for extents
-			 * we failed to store.
-			 */
-			segs = err;
-			goto out_release;
-		}
-		log_balloc(sb, seg[i].block, seg[i].count);
-		trace("fill in %Lx/%i ", seg[i].block, seg[i].count);
-
-		/* if mode == MAP_REDIRECT, buffer should be dirty */
-		seg[i].state = (mode == MAP_REDIRECT) ? 0 : BLOCK_SEG_NEW;
-	}
-
-	/* Start to reflect the seg[] changes to the data btree */
-	if ((err = cursor_redirect(cursor))) {
-		segs = err;
-		goto out_release;
-	}
-	/* Update redirected place for local variables */
-	dwalk_redirect(walk, leaf, bufdata(cursor_leafbuf(cursor)));
-	dwalk_redirect(&headwalk, leaf, bufdata(cursor_leafbuf(cursor)));
-	leaf = bufdata(cursor_leafbuf(cursor));
-
-	struct dleaf *tail = NULL;
-	tuxkey_t tailkey = 0; // probably can just use limit instead
-	if (!dwalk_end(walk)) {
-		tail = kmalloc(sb->blocksize, GFP_NOFS); // error???
-		dleaf_init(btree, tail);
-		tailkey = dwalk_index(walk);
-		dwalk_copy(walk, tail);
-	}
-	/* Go back to region start and pack in new seg */
-	dwalk_chop(&headwalk);
-	index = start;
-	for (int i = -!!below; i < segs + !!above; i++) {
-		if (dleaf_free(btree, leaf) < DLEAF_MAX_EXTENT_SIZE) {
-			mark_buffer_dirty_non(cursor_leafbuf(cursor));
-			struct buffer_head *newbuf = new_leaf(btree);
-			if (IS_ERR(newbuf)) {
-				segs = PTR_ERR(newbuf);
-				goto out_create;
-			}
-			log_balloc(sb, bufindex(newbuf), 1);
-			/*
-			 * ENOSPC on btree index split could leave the
-			 * cache state badly messed up.  Going to have
-			 * to do this in two steps: first, look at the
-			 * cursor to see how many splits we need, then
-			 * make sure we have that, or give up before
-			 * starting.
-			 */
-			btree_insert_leaf(cursor, index, newbuf);
-			leaf = bufdata(cursor_leafbuf(cursor));
-			dwalk_probe(leaf, sb->blocksize, &headwalk, index);
-		}
-		if (i < 0) {
-			trace("emit below");
-			dwalk_add(&headwalk, seg_start, make_extent(below_block, below));
-			continue;
-		}
-		if (i == segs) {
-			trace("emit above");
-			dwalk_add(&headwalk, index, make_extent(above_block, above));
-			continue;
-		}
-		trace("pack 0x%Lx => %Lx/%x", index, seg[i].block, seg[i].count);
-		dleaf_dump(btree, leaf);
-		dwalk_add(&headwalk, index, make_extent(seg[i].block, seg[i].count));
-		dleaf_dump(btree, leaf);
-		index += seg[i].count;
-	}
-	if (tail) {
-		if (!dleaf_merge(btree, leaf, tail)) {
-			mark_buffer_dirty_non(cursor_leafbuf(cursor));
-			assert(dleaf_groups(tail) >= 1);
-			/* Tail does not fit, add it as a new btree leaf */
-			struct buffer_head *newbuf = new_leaf(btree);
-			if (IS_ERR(newbuf)) {
-				segs = PTR_ERR(newbuf);
-				goto out_create;
-			}
-			memcpy(bufdata(newbuf), tail, sb->blocksize);
-			log_balloc(sb, bufindex(newbuf), 1);
-			if ((err = btree_insert_leaf(cursor, tailkey, newbuf))) {
-				segs = err;
-				goto out_create;
-			}
-		}
-	}
-	mark_buffer_dirty_non(cursor_leafbuf(cursor));
-out_create:
-	if (tail)
-		kfree(tail);
-out_release:
-	if (cursor)
-		release_cursor(cursor);
-out_unlock:
-	if (tux_inode(inode)->inum != TUX_BITMAP_INO) {
-		if (mode == MAP_READ)
-			up_read(&btree->lock);
-		else
-			up_write(&btree->lock);
-	}
-	if (cursor)
-		free_cursor(cursor);
-
-	return segs;
-}
-
 static void seg_free(struct btree *btree, block_t block, unsigned count)
 {
 	map_bfree(btree_inode(btree), block, count);
@@ -562,7 +288,6 @@
 		      struct block_segment seg[], unsigned seg_max,
 		      enum map_mode mode)
 {
-	struct btree *btree = &tux_inode(inode)->btree;
 	int segs;
 
 	/*
@@ -581,10 +306,7 @@
 		}
 	}
 
-	if (btree->ops == &dtree1_ops)
-		segs = map_region1(inode, start, count, seg, seg_max, mode);
-	else
-		segs = map_region2(inode, start, count, seg, seg_max, mode);
+	segs = map_region2(inode, start, count, seg, seg_max, mode);
 
 	if (mode == MAP_READ) {
 		/* Update seg[] with hole information */