libgtk3: remove non-existent configure options

[buildroot-gz.git] / package / genext2fs / 0001-update-genext2fs.c-to-rev-1.118.patch

[PATCH] update genext2fs.c to CVS rev 1.118

See http://genext2fs.cvs.sourceforge.net/viewvc/genext2fs/genext2fs/genext2fs.c?view=log
for details.

Numerous bugfixes, large file and filesystem support, rev 1 filesystems,
volume id support, block size, ..

Signed-off-by: Peter Korsgaard <jacmet@sunsite.dk>
---
 cache.h     |  128 ++++
 genext2fs.c | 1870 ++++++++++++++++++++++++++++++++++++++++++------------------
 list.h      |   78 ++
 3 files changed, 1527 insertions(+), 549 deletions(-)

Index: genext2fs-1.4.1/genext2fs.c
===================================================================
--- genext2fs-1.4.1.orig/genext2fs.c
+++ genext2fs-1.4.1/genext2fs.c
@@ -53,6 +53,12 @@
 //                     along with -q, -P, -U
 
 
+/*
+ * Allow fseeko/off_t to be 64-bit offsets to allow filesystems and
+ * individual files >2GB.
+ */
+#define _FILE_OFFSET_BITS 64
+
 #include <config.h>
 #include <stdio.h>
 
@@ -107,10 +113,8 @@
 
 #if HAVE_DIRENT_H
 # include <dirent.h>
-# define NAMLEN(dirent) strlen((dirent)->d_name)
 #else
 # define dirent direct
-# define NAMLEN(dirent) (dirent)->d_namlen
 # if HAVE_SYS_NDIR_H
 #  include <sys/ndir.h>
 # endif
@@ -144,6 +148,8 @@
 # include <limits.h>
 #endif
 
+#include "cache.h"
+
 struct stats {
        unsigned long nblocks;
        unsigned long ninodes;
@@ -151,13 +157,42 @@
 
 // block size
 
-#define BLOCKSIZE         1024
+static int blocksize = 1024;
+
+#define SUPERBLOCK_OFFSET      1024
+#define SUPERBLOCK_SIZE                1024
+
+#define BLOCKSIZE         blocksize
 #define BLOCKS_PER_GROUP  8192
 #define INODES_PER_GROUP  8192
 /* Percentage of blocks that are reserved.*/
 #define RESERVED_BLOCKS       5/100
 #define MAX_RESERVED_BLOCKS  25/100
 
+/* The default value for s_creator_os. */
+#if defined(__linux__)    &&    defined(EXT2_OS_LINUX)
+#define CREATOR_OS EXT2_OS_LINUX
+#define CREATOR_OS_NAME "linux"
+#else
+#if defined(__GNU__)     &&     defined(EXT2_OS_HURD)
+#define CREATOR_OS EXT2_OS_HURD
+#define CREATOR_OS_NAME "hurd"
+#else
+#if defined(__FreeBSD__) &&     defined(EXT2_OS_FREEBSD)
+#define CREATOR_OS EXT2_OS_FREEBSD
+#define CREATOR_OS_NAME "freebsd"
+#else
+#if defined(LITES)         &&   defined(EXT2_OS_LITES)
+#define CREATOR_OS EXT2_OS_LITES
+#define CREATOR_OS_NAME "lites"
+#else
+#define CREATOR_OS EXT2_OS_LINUX /* by default */
+#define CREATOR_OS_NAME "linux"
+#endif /* defined(LITES) && defined(EXT2_OS_LITES) */
+#endif /* defined(__FreeBSD__) && defined(EXT2_OS_FREEBSD) */
+#endif /* defined(__GNU__)     && defined(EXT2_OS_HURD) */
+#endif /* defined(__linux__)   && defined(EXT2_OS_LINUX) */
+
 
 // inode block size (why is it != BLOCKSIZE ?!?)
 /* The field i_blocks in the ext2 inode stores the number of data blocks
@@ -190,6 +225,14 @@
 #define EXT2_TIND_BLOCK    14                    // triple indirect block
 #define EXT2_INIT_BLOCK    0xFFFFFFFF            // just initialized (not really a block address)
 
+// codes for operating systems
+
+#define EXT2_OS_LINUX           0
+#define EXT2_OS_HURD            1
+#define EXT2_OS_MASIX           2
+#define EXT2_OS_FREEBSD         3
+#define EXT2_OS_LITES           4
+
 // end of a block walk
 
 #define WALK_END           0xFFFFFFFE
@@ -227,44 +270,46 @@
 #define FM_IWOTH   0000002     // write
 #define FM_IXOTH   0000001     // execute
 
-// options
-
-#define OP_HOLES     0x01       // make files with holes
-
 /* Defines for accessing group details */
 
 // Number of groups in the filesystem
 #define GRP_NBGROUPS(fs) \
-       (((fs)->sb.s_blocks_count - fs->sb.s_first_data_block + \
-         (fs)->sb.s_blocks_per_group - 1) / (fs)->sb.s_blocks_per_group)
+       (((fs)->sb->s_blocks_count - fs->sb->s_first_data_block + \
+         (fs)->sb->s_blocks_per_group - 1) / (fs)->sb->s_blocks_per_group)
 
 // Get group block bitmap (bbm) given the group number
-#define GRP_GET_GROUP_BBM(fs,grp) ( get_blk((fs),(fs)->gd[(grp)].bg_block_bitmap) )
+#define GRP_GET_GROUP_BBM(fs,grp,bi) (get_blk((fs),(grp)->bg_block_bitmap,(bi)))
+#define GRP_PUT_GROUP_BBM(bi) ( put_blk((bi)) )
 
 // Get group inode bitmap (ibm) given the group number
-#define GRP_GET_GROUP_IBM(fs,grp) ( get_blk((fs),(fs)->gd[(grp)].bg_inode_bitmap) )
-               
+#define GRP_GET_GROUP_IBM(fs,grp,bi) (get_blk((fs), (grp)->bg_inode_bitmap,(bi)))
+#define GRP_PUT_GROUP_IBM(bi) ( put_blk((bi)) )
+
 // Given an inode number find the group it belongs to
-#define GRP_GROUP_OF_INODE(fs,nod) ( ((nod)-1) / (fs)->sb.s_inodes_per_group)
+#define GRP_GROUP_OF_INODE(fs,nod) ( ((nod)-1) / (fs)->sb->s_inodes_per_group)
 
 //Given an inode number get the inode bitmap that covers it
-#define GRP_GET_INODE_BITMAP(fs,nod) \
-       ( GRP_GET_GROUP_IBM((fs),GRP_GROUP_OF_INODE((fs),(nod))) )
+#define GRP_GET_INODE_BITMAP(fs,nod,bi,gi)                             \
+       ( GRP_GET_GROUP_IBM((fs),get_gd(fs,GRP_GROUP_OF_INODE((fs),(nod)),gi),bi) )
+#define GRP_PUT_INODE_BITMAP(bi,gi)            \
+       ( GRP_PUT_GROUP_IBM((bi)),put_gd((gi)) )
 
 //Given an inode number find its offset within the inode bitmap that covers it
 #define GRP_IBM_OFFSET(fs,nod) \
-       ( (nod) - GRP_GROUP_OF_INODE((fs),(nod))*(fs)->sb.s_inodes_per_group )
+       ( (nod) - GRP_GROUP_OF_INODE((fs),(nod))*(fs)->sb->s_inodes_per_group )
 
 // Given a block number find the group it belongs to
-#define GRP_GROUP_OF_BLOCK(fs,blk) ( ((blk)-1) / (fs)->sb.s_blocks_per_group)
+#define GRP_GROUP_OF_BLOCK(fs,blk) ( ((blk)-1) / (fs)->sb->s_blocks_per_group)
        
-//Given a block number get the block bitmap that covers it
-#define GRP_GET_BLOCK_BITMAP(fs,blk) \
-       ( GRP_GET_GROUP_BBM((fs),GRP_GROUP_OF_BLOCK((fs),(blk))) )
+//Given a block number get/put the block bitmap that covers it
+#define GRP_GET_BLOCK_BITMAP(fs,blk,bi,gi)                             \
+       ( GRP_GET_GROUP_BBM((fs),get_gd(fs,GRP_GROUP_OF_BLOCK((fs),(blk)),(gi)),(bi)) )
+#define GRP_PUT_BLOCK_BITMAP(bi,gi)            \
+       ( GRP_PUT_GROUP_BBM((bi)),put_gd((gi)) )
 
 //Given a block number find its offset within the block bitmap that covers it
 #define GRP_BBM_OFFSET(fs,blk) \
-       ( (blk) - GRP_GROUP_OF_BLOCK((fs),(blk))*(fs)->sb.s_blocks_per_group )
+       ( (blk) - GRP_GROUP_OF_BLOCK((fs),(blk))*(fs)->sb->s_blocks_per_group )
 
 
 // used types
@@ -286,7 +331,9 @@
 // older solaris. Note that this is still not very portable, in that
 // the return value cannot be trusted.
 
-#if SCANF_CAN_MALLOC
+#if 0 // SCANF_CAN_MALLOC
+// C99 define "a" for floating point, so you can have runtime surprise
+// according the library versions
 # define SCANF_PREFIX "a"
 # define SCANF_STRING(s) (&s)
 #else
@@ -430,6 +477,17 @@
                        ((val<<8)&0xFF0000) | (val<<24));
 }
 
+static inline int
+is_blk_empty(uint8 *b)
+{
+       uint32 i;
+       uint32 *v = (uint32 *) b;
+
+       for(i = 0; i < BLOCKSIZE / 4; i++)
+               if (*v++)
+                       return 0;
+       return 1;
+}
 
 // on-disk structures
 // this trick makes me declare things only once
@@ -460,7 +518,22 @@
        udecl32(s_creator_os)          /* Indicator of which OS created the filesystem */ \
        udecl32(s_rev_level)           /* The revision level of the filesystem */ \
        udecl16(s_def_resuid)          /* The default uid for reserved blocks */ \
-       udecl16(s_def_resgid)          /* The default gid for reserved blocks */
+       udecl16(s_def_resgid)          /* The default gid for reserved blocks */ \
+       /* rev 1 version fields start here */ \
+       udecl32(s_first_ino)            /* First non-reserved inode */  \
+       udecl16(s_inode_size)           /* size of inode structure */   \
+       udecl16(s_block_group_nr)       /* block group # of this superblock */ \
+       udecl32(s_feature_compat)       /* compatible feature set */    \
+       udecl32(s_feature_incompat)     /* incompatible feature set */  \
+       udecl32(s_feature_ro_compat)    /* readonly-compatible feature set */ \
+       utdecl8(s_uuid,16)              /* 128-bit uuid for volume */   \
+       utdecl8(s_volume_name,16)       /* volume name */               \
+       utdecl8(s_last_mounted,64)      /* directory where last mounted */ \
+       udecl32(s_algorithm_usage_bitmap) /* For compression */
+
+#define EXT2_GOOD_OLD_FIRST_INO        11
+#define EXT2_GOOD_OLD_INODE_SIZE 128
+#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE      0x0002
 
 #define groupdescriptor_decl \
        udecl32(bg_block_bitmap)       /* Block number of the block bitmap */ \
@@ -500,6 +573,7 @@
 
 #define decl8(x) int8 x;
 #define udecl8(x) uint8 x;
+#define utdecl8(x,n) uint8 x[n];
 #define decl16(x) int16 x;
 #define udecl16(x) uint16 x;
 #define decl32(x) int32 x;
@@ -509,7 +583,7 @@
 typedef struct
 {
        superblock_decl
-       uint32 s_reserved[235];       // Reserved
+       uint32 s_reserved[205];       // Reserved
 } superblock;
 
 typedef struct
@@ -527,10 +601,9 @@
 typedef struct
 {
        directory_decl
-       char d_name[0];
 } directory;
 
-typedef uint8 block[BLOCKSIZE];
+typedef uint8 *block;
 
 /* blockwalker fields:
    The blockwalker is used to access all the blocks of a file (including
@@ -567,23 +640,41 @@
        uint32 bptind;
 } blockwalker;
 
+#define HDLINK_CNT   16
+struct hdlink_s
+{
+       uint32  src_inode;
+       uint32  dst_nod;
+};
+
+struct hdlinks_s
+{
+       int32 count;
+       struct hdlink_s *hdl;
+};
 
 /* Filesystem structure that support groups */
-#if BLOCKSIZE == 1024
 typedef struct
 {
-       block zero;            // The famous block 0
-       superblock sb;         // The superblock
-       groupdescriptor gd[0]; // The group descriptors
+       FILE *f;
+       superblock *sb;
+       int swapit;
+       int32 hdlink_cnt;
+       struct hdlinks_s hdlinks;
+
+       int holes;
+
+       listcache blks;
+       listcache gds;
+       listcache inodes;
+       listcache blkmaps;
 } filesystem;
-#else
-#error UNHANDLED BLOCKSIZE
-#endif
 
 // now the endianness swap
 
 #undef decl8
 #undef udecl8
+#undef utdecl8
 #undef decl16
 #undef udecl16
 #undef decl32
@@ -592,28 +683,13 @@
 
 #define decl8(x)
 #define udecl8(x)
+#define utdecl8(x,n)
 #define decl16(x) this->x = swab16(this->x);
 #define udecl16(x) this->x = swab16(this->x);
 #define decl32(x) this->x = swab32(this->x);
 #define udecl32(x) this->x = swab32(this->x);
 #define utdecl32(x,n) { int i; for(i=0; i<n; i++) this->x[i] = swab32(this->x[i]); }
 
-#define HDLINK_CNT   16
-static int32 hdlink_cnt = HDLINK_CNT;
-struct hdlink_s
-{
-       uint32  src_inode;
-       uint32  dst_nod;
-};
-
-struct hdlinks_s 
-{
-       int32 count;
-       struct hdlink_s *hdl;
-};
-
-static struct hdlinks_s hdlinks;
-
 static void
 swap_sb(superblock *sb)
 {
@@ -633,9 +709,24 @@
 static void
 swap_nod(inode *nod)
 {
+       uint32 nblk;
+
 #define this nod
        inode_decl
 #undef this
+
+       // block and character inodes store the major and minor in the
+       // i_block, so we need to unswap to get those.  Also, if it's
+       // zero iblocks, put the data back like it belongs.
+       nblk = nod->i_blocks / INOBLK;
+       if ((nod->i_size && !nblk)
+           || ((nod->i_mode & FM_IFBLK) == FM_IFBLK)
+           || ((nod->i_mode & FM_IFCHR) == FM_IFCHR))
+       {
+               int i;
+               for(i = 0; i <= EXT2_TIND_BLOCK; i++)
+                       nod->i_block[i] = swab32(nod->i_block[i]);
+       }
 }
 
 static void
@@ -657,6 +748,7 @@
 
 #undef decl8
 #undef udecl8
+#undef utdecl8
 #undef decl16
 #undef udecl16
 #undef decl32
@@ -770,15 +862,15 @@
 }
 
 int
-is_hardlink(ino_t inode)
+is_hardlink(filesystem *fs, ino_t inode)
 {
        int i;
 
-       for(i = 0; i < hdlinks.count; i++) {
-               if(hdlinks.hdl[i].src_inode == inode)
+       for(i = 0; i < fs->hdlinks.count; i++) {
+               if(fs->hdlinks.hdl[i].src_inode == inode)
                        return i;
        }
-       return -1;              
+       return -1;
 }
 
 // printf helper macro
@@ -789,6 +881,8 @@
 get_workblk(void)
 {
        unsigned char* b=calloc(1,BLOCKSIZE);
+       if (!b)
+               error_msg_and_die("get_workblk() failed, out of memory");
        return b;
 }
 static inline void
@@ -811,24 +905,464 @@
        return b[(item-1) / 8] & (1 << ((item-1) % 8));
 }
 
-// return a given block from a filesystem
+// Used by get_blk/put_blk to hold information about a block owned
+// by the user.
+typedef struct
+{
+       cache_link link;
+
+       filesystem *fs;
+       uint32 blk;
+       uint8 *b;
+       uint32 usecount;
+} blk_info;
+
+#define MAX_FREE_CACHE_BLOCKS 100
+
+static uint32
+blk_elem_val(cache_link *elem)
+{
+       blk_info *bi = container_of(elem, blk_info, link);
+       return bi->blk;
+}
+
+static void
+blk_freed(cache_link *elem)
+{
+       blk_info *bi = container_of(elem, blk_info, link);
+
+       if (fseeko(bi->fs->f, ((off_t) bi->blk) * BLOCKSIZE, SEEK_SET))
+               perror_msg_and_die("fseek");
+       if (fwrite(bi->b, BLOCKSIZE, 1, bi->fs->f) != 1)
+               perror_msg_and_die("get_blk: write");
+       free(bi->b);
+       free(bi);
+}
+
+// Return a given block from a filesystem.  Make sure to call
+// put_blk when you are done with it.
 static inline uint8 *
-get_blk(filesystem *fs, uint32 blk)
+get_blk(filesystem *fs, uint32 blk, blk_info **rbi)
 {
-       return (uint8*)fs + blk*BLOCKSIZE;
+       cache_link *curr;
+       blk_info *bi;
+
+       if (blk >= fs->sb->s_blocks_count)
+               error_msg_and_die("Internal error, block out of range");
+
+       curr = cache_find(&fs->blks, blk);
+       if (curr) {
+               bi = container_of(curr, blk_info, link);
+               bi->usecount++;
+               goto out;
+       }
+
+       bi = malloc(sizeof(*bi));
+       if (!bi)
+               error_msg_and_die("get_blk: out of memory");
+       bi->fs = fs;
+       bi->blk = blk;
+       bi->usecount = 1;
+       bi->b = malloc(BLOCKSIZE);
+       if (!bi->b)
+               error_msg_and_die("get_blk: out of memory");
+       cache_add(&fs->blks, &bi->link);
+       if (fseeko(fs->f, ((off_t) blk) * BLOCKSIZE, SEEK_SET))
+               perror_msg_and_die("fseek");
+       if (fread(bi->b, BLOCKSIZE, 1, fs->f) != 1) {
+               if (ferror(fs->f))
+                       perror_msg_and_die("fread");
+               memset(bi->b, 0, BLOCKSIZE);
+       }
+
+out:
+       *rbi = bi;
+       return bi->b;
 }
 
 // return a given inode from a filesystem
-static inline inode *
-get_nod(filesystem *fs, uint32 nod)
+static inline void
+put_blk(blk_info *bi)
+{
+       if (bi->usecount == 0)
+               error_msg_and_die("Internal error: put_blk usecount zero");
+       bi->usecount--;
+       if (bi->usecount == 0)
+               /* Free happens in the cache code */
+               cache_item_set_unused(&bi->fs->blks, &bi->link);
+}
+
+typedef struct
 {
-       int grp,offset;
+       cache_link link;
+
+       filesystem *fs;
+       int gds;
+       blk_info *bi;
+       groupdescriptor *gd;
+       uint32 usecount;
+} gd_info;
+
+#define MAX_FREE_CACHE_GDS 100
+
+static uint32
+gd_elem_val(cache_link *elem)
+{
+       gd_info *gi = container_of(elem, gd_info, link);
+       return gi->gds;
+}
+
+static void
+gd_freed(cache_link *elem)
+{
+       gd_info *gi = container_of(elem, gd_info, link);
+
+       if (gi->fs->swapit)
+               swap_gd(gi->gd);
+       put_blk(gi->bi);
+       free(gi);
+}
+
+#define GDS_START ((SUPERBLOCK_OFFSET + SUPERBLOCK_SIZE + BLOCKSIZE - 1) / BLOCKSIZE)
+#define GDS_PER_BLOCK (BLOCKSIZE / sizeof(groupdescriptor))
+// the group descriptors are aligned on the block size
+static inline groupdescriptor *
+get_gd(filesystem *fs, uint32 no, gd_info **rgi)
+{
+       uint32 gdblk;
+       uint32 offset;
+       gd_info *gi;
+       cache_link *curr;
+
+       curr = cache_find(&fs->gds, no);
+       if (curr) {
+               gi = container_of(curr, gd_info, link);
+               gi->usecount++;
+               goto out;
+       }
+
+       gi = malloc(sizeof(*gi));
+       if (!gi)
+               error_msg_and_die("get_gd: out of memory");
+       gi->fs = fs;
+       gi->gds = no;
+       gi->usecount = 1;
+       gdblk = GDS_START + (no / GDS_PER_BLOCK);
+       offset = no % GDS_PER_BLOCK;
+       gi->gd = ((groupdescriptor *) get_blk(fs, gdblk, &gi->bi)) + offset;
+       cache_add(&fs->gds, &gi->link);
+       if (fs->swapit)
+               swap_gd(gi->gd);
+ out:
+       *rgi = gi;
+
+       return gi->gd;
+}
+
+static inline void
+put_gd(gd_info *gi)
+{
+       if (gi->usecount == 0)
+               error_msg_and_die("Internal error: put_gd usecount zero");
+
+       gi->usecount--;
+       if (gi->usecount == 0)
+               /* Free happens in the cache code */
+               cache_item_set_unused(&gi->fs->gds, &gi->link);
+}
+
+// Used by get_blkmap/put_blkmap to hold information about an block map
+// owned by the user.
+typedef struct
+{
+       cache_link link;
+
+       filesystem *fs;
+       uint32 blk;
+       uint8 *b;
+       blk_info *bi;
+       uint32 usecount;
+} blkmap_info;
+
+#define MAX_FREE_CACHE_BLOCKMAPS 100
+
+static uint32
+blkmap_elem_val(cache_link *elem)
+{
+       blkmap_info *bmi = container_of(elem, blkmap_info, link);
+       return bmi->blk;
+}
+
+static void
+blkmap_freed(cache_link *elem)
+{
+       blkmap_info *bmi = container_of(elem, blkmap_info, link);
+
+       if (bmi->fs->swapit)
+               swap_block(bmi->b);
+       put_blk(bmi->bi);
+       free(bmi);
+}
+
+// Return a given block map from a filesystem.  Make sure to call
+// put_blkmap when you are done with it.
+static inline uint32 *
+get_blkmap(filesystem *fs, uint32 blk, blkmap_info **rbmi)
+{
+       blkmap_info *bmi;
+       cache_link *curr;
+
+       curr = cache_find(&fs->blkmaps, blk);
+       if (curr) {
+               bmi = container_of(curr, blkmap_info, link);
+               bmi->usecount++;
+               goto out;
+       }
+
+       bmi = malloc(sizeof(*bmi));
+       if (!bmi)
+               error_msg_and_die("get_blkmap: out of memory");
+       bmi->fs = fs;
+       bmi->blk = blk;
+       bmi->b = get_blk(fs, blk, &bmi->bi);
+       bmi->usecount = 1;
+       cache_add(&fs->blkmaps, &bmi->link);
+
+       if (fs->swapit)
+               swap_block(bmi->b);
+ out:
+       *rbmi = bmi;
+       return (uint32 *) bmi->b;
+}
+
+static inline void
+put_blkmap(blkmap_info *bmi)
+{
+       if (bmi->usecount == 0)
+               error_msg_and_die("Internal error: put_blkmap usecount zero");
+
+       bmi->usecount--;
+       if (bmi->usecount == 0)
+               /* Free happens in the cache code */
+               cache_item_set_unused(&bmi->fs->blkmaps, &bmi->link);
+}
+
+// Used by get_nod/put_nod to hold information about an inode owned
+// by the user.
+typedef struct
+{
+       cache_link link;
+
+       filesystem *fs;
+       uint32 nod;
+       uint8 *b;
+       blk_info *bi;
        inode *itab;
+       uint32 usecount;
+} nod_info;
+
+#define MAX_FREE_CACHE_INODES 100
+
+static uint32
+inode_elem_val(cache_link *elem)
+{
+       nod_info *ni = container_of(elem, nod_info, link);
+       return ni->nod;
+}
+
+static void
+inode_freed(cache_link *elem)
+{
+       nod_info *ni = container_of(elem, nod_info, link);
+
+       if (ni->fs->swapit)
+               swap_nod(ni->itab);
+       put_blk(ni->bi);
+       free(ni);
+}
+
+#define INODES_PER_BLOCK (BLOCKSIZE / sizeof(inode))
 
-       offset = GRP_IBM_OFFSET(fs,nod);
+// return a given inode from a filesystem
+static inline inode *
+get_nod(filesystem *fs, uint32 nod, nod_info **rni)
+{
+       uint32 grp, boffset, offset;
+       cache_link *curr;
+       groupdescriptor *gd;
+       gd_info *gi;
+       nod_info *ni;
+
+       curr = cache_find(&fs->inodes, nod);
+       if (curr) {
+               ni = container_of(curr, nod_info, link);
+               ni->usecount++;
+               goto out;
+       }
+
+       ni = malloc(sizeof(*ni));
+       if (!ni)
+               error_msg_and_die("get_nod: out of memory");
+       ni->fs = fs;
+       ni->nod = nod;
+       ni->usecount = 1;
+       cache_add(&fs->inodes, &ni->link);
+
+       offset = GRP_IBM_OFFSET(fs,nod) - 1;
+       boffset = offset / INODES_PER_BLOCK;
+       offset %= INODES_PER_BLOCK;
        grp = GRP_GROUP_OF_INODE(fs,nod);
-       itab = (inode *)get_blk(fs, fs->gd[grp].bg_inode_table);
-       return itab+offset-1;
+       gd = get_gd(fs, grp, &gi);
+       ni->b = get_blk(fs, gd->bg_inode_table + boffset, &ni->bi);
+       ni->itab = ((inode *) ni->b) + offset;
+       if (fs->swapit)
+               swap_nod(ni->itab);
+       put_gd(gi);
+ out:
+       *rni = ni;
+       return ni->itab;
+}
+
+static inline void
+put_nod(nod_info *ni)
+{
+       if (ni->usecount == 0)
+               error_msg_and_die("Internal error: put_nod usecount zero");
+
+       ni->usecount--;
+       if (ni->usecount == 0)
+               /* Free happens in the cache code */
+               cache_item_set_unused(&ni->fs->inodes, &ni->link);
+}
+
+// Used to hold state information while walking a directory inode.
+typedef struct
+{
+       directory d;
+       filesystem *fs;
+       uint32 nod;
+       directory *last_d;
+       uint8 *b;
+       blk_info *bi;
+} dirwalker;
+
+// Start a directory walk on the given inode.  You must pass in a
+// dirwalker structure, then use that dirwalker for future operations.
+// Call put_dir when you are done walking the directory.
+static inline directory *
+get_dir(filesystem *fs, uint32 nod, dirwalker *dw)
+{
+       dw->fs = fs;
+       dw->b = get_blk(fs, nod, &dw->bi);
+       dw->nod = nod;
+       dw->last_d = (directory *) dw->b;
+
+       memcpy(&dw->d, dw->last_d, sizeof(directory));
+       if (fs->swapit)
+               swap_dir(&dw->d);
+       return &dw->d;
+}
+
+// Move to the next directory.
+static inline directory *
+next_dir(dirwalker *dw)
+{
+       directory *next_d = (directory *)((int8*)dw->last_d + dw->d.d_rec_len);
+
+       if (dw->fs->swapit)
+               swap_dir(&dw->d);
+       memcpy(dw->last_d, &dw->d, sizeof(directory));
+
+       if (((int8 *) next_d) >= ((int8 *) dw->b + BLOCKSIZE))
+               return NULL;
+
+       dw->last_d = next_d;
+       memcpy(&dw->d, next_d, sizeof(directory));
+       if (dw->fs->swapit)
+               swap_dir(&dw->d);
+       return &dw->d;
+}
+
+// Call then when you are done with the directory walk.
+static inline void
+put_dir(dirwalker *dw)
+{
+       if (dw->fs->swapit)
+               swap_dir(&dw->d);
+       memcpy(dw->last_d, &dw->d, sizeof(directory));
+
+       if (dw->nod == 0)
+               free_workblk(dw->b);
+       else
+               put_blk(dw->bi);
+}
+
+// Create a new directory block with the given inode as it's destination
+// and append it to the current dirwalker.
+static directory *
+new_dir(filesystem *fs, uint32 dnod, const char *name, int nlen, dirwalker *dw)
+{
+       directory *d;
+
+       dw->fs = fs;
+       dw->b = get_workblk();
+       dw->nod = 0;
+       dw->last_d = (directory *) dw->b;
+       d = &dw->d;
+       d->d_inode = dnod;
+       d->d_rec_len = BLOCKSIZE;
+       d->d_name_len = nlen;
+       strncpy(((char *) dw->last_d) + sizeof(directory), name, nlen);
+       return d;
+}
+
+// Shrink the current directory entry, make a new one with the free
+// space, and return the new directory entry (making it current).
+static inline directory *
+shrink_dir(dirwalker *dw, uint32 nod, const char *name, int nlen)
+{
+       int reclen, preclen;
+       directory *d = &dw->d;
+
+       reclen = d->d_rec_len;
+       d->d_rec_len = sizeof(directory) + rndup(d->d_name_len, 4);
+       preclen = d->d_rec_len;
+       reclen -= preclen;
+       if (dw->fs->swapit)
+               swap_dir(&dw->d);
+       memcpy(dw->last_d, &dw->d, sizeof(directory));
+
+       dw->last_d = (directory *) (((int8 *) dw->last_d) + preclen);
+       d->d_rec_len = reclen;
+       d->d_inode = nod;
+       d->d_name_len = nlen;
+       strncpy(((char *) dw->last_d) + sizeof(directory), name, nlen);
+
+       return d;
+}
+
+// Return the current block the directory is walking
+static inline uint8 *
+dir_data(dirwalker *dw)
+{
+       return dw->b;
+}
+
+// Return the pointer to the name for the current directory
+static inline char *
+dir_name(dirwalker *dw)
+{
+       return ((char *) dw->last_d) + sizeof(directory);
+}
+
+// Set the name for the current directory.  Note that this doesn't
+// verify that there is space for the directory name, you must do
+// that yourself.
+static void
+dir_set_name(dirwalker *dw, const char *name, int nlen)
+{
+       dw->d.d_name_len = nlen;
+       strncpy(((char *) dw->last_d) + sizeof(directory), name, nlen);
 }
 
 // allocate a given block/inode in the bitmap
@@ -870,21 +1404,34 @@
 {
        uint32 bk=0;
        uint32 grp,nbgroups;
+       blk_info *bi;
+       groupdescriptor *gd;
+       gd_info *gi;
 
        grp = GRP_GROUP_OF_INODE(fs,nod);
        nbgroups = GRP_NBGROUPS(fs);
-       if(!(bk = allocate(get_blk(fs,fs->gd[grp].bg_block_bitmap), 0))) {
-               for(grp=0;grp<nbgroups && !bk;grp++)
-                       bk=allocate(get_blk(fs,fs->gd[grp].bg_block_bitmap),0);
+       gd = get_gd(fs, grp, &gi);
+       bk = allocate(GRP_GET_GROUP_BBM(fs, gd, &bi), 0);
+       GRP_PUT_GROUP_BBM(bi);
+       put_gd(gi);
+       if (!bk) {
+               for (grp=0; grp<nbgroups && !bk; grp++) {
+                       gd = get_gd(fs, grp, &gi);
+                       bk = allocate(GRP_GET_GROUP_BBM(fs, gd, &bi), 0);
+                       GRP_PUT_GROUP_BBM(bi);
+                       put_gd(gi);
+               }
                grp--;
        }
        if (!bk)
                error_msg_and_die("couldn't allocate a block (no free space)");
-       if(!(fs->gd[grp].bg_free_blocks_count--))
+       gd = get_gd(fs, grp, &gi);
+       if(!(gd->bg_free_blocks_count--))
                error_msg_and_die("group descr %d. free blocks count == 0 (corrupted fs?)",grp);
-       if(!(fs->sb.s_free_blocks_count--))
+       put_gd(gi);
+       if(!(fs->sb->s_free_blocks_count--))
                error_msg_and_die("superblock free blocks count == 0 (corrupted fs?)");
-       return fs->sb.s_blocks_per_group*grp + bk;
+       return fs->sb->s_first_data_block + fs->sb->s_blocks_per_group*grp + (bk-1);
 }
 
 // free a block
@@ -892,12 +1439,18 @@
 free_blk(filesystem *fs, uint32 bk)
 {
        uint32 grp;
-
-       grp = bk / fs->sb.s_blocks_per_group;
-       bk %= fs->sb.s_blocks_per_group;
-       deallocate(get_blk(fs,fs->gd[grp].bg_block_bitmap), bk);
-       fs->gd[grp].bg_free_blocks_count++;
-       fs->sb.s_free_blocks_count++;
+       blk_info *bi;
+       gd_info *gi;
+       groupdescriptor *gd;
+
+       grp = bk / fs->sb->s_blocks_per_group;
+       bk %= fs->sb->s_blocks_per_group;
+       gd = get_gd(fs, grp, &gi);
+       deallocate(GRP_GET_GROUP_BBM(fs, gd, &bi), bk);
+       GRP_PUT_GROUP_BBM(bi);
+       gd->bg_free_blocks_count++;
+       put_gd(gi);
+       fs->sb->s_free_blocks_count++;
 }
 
 // allocate an inode
@@ -906,6 +1459,9 @@
 {
        uint32 nod,best_group=0;
        uint32 grp,nbgroups,avefreei;
+       blk_info *bi;
+       gd_info *gi, *bestgi;
+       groupdescriptor *gd, *bestgd;
 
        nbgroups = GRP_NBGROUPS(fs);
 
@@ -914,22 +1470,32 @@
        /* find the one with the most free blocks and allocate node there     */
        /* Idea from find_group_dir in fs/ext2/ialloc.c in 2.4.19 kernel      */
        /* We do it for all inodes.                                           */
-       avefreei  =  fs->sb.s_free_inodes_count / nbgroups;
+       avefreei  =  fs->sb->s_free_inodes_count / nbgroups;
+       bestgd = get_gd(fs, best_group, &bestgi);
        for(grp=0; grp<nbgroups; grp++) {
-               if (fs->gd[grp].bg_free_inodes_count < avefreei ||
-                   fs->gd[grp].bg_free_inodes_count == 0)
+               gd = get_gd(fs, grp, &gi);
+               if (gd->bg_free_inodes_count < avefreei ||
+                   gd->bg_free_inodes_count == 0) {
+                       put_gd(gi);
                        continue;
-               if (!best_group || 
-                       fs->gd[grp].bg_free_blocks_count > fs->gd[best_group].bg_free_blocks_count)
+               }
+               if (!best_group || gd->bg_free_blocks_count > bestgd->bg_free_blocks_count) {
+                       put_gd(bestgi);
                        best_group = grp;
+                       bestgd = gd;
+                       bestgi = gi;
+               } else
+                       put_gd(gi);
        }
-       if (!(nod = allocate(get_blk(fs,fs->gd[best_group].bg_inode_bitmap),0)))
+       if (!(nod = allocate(GRP_GET_GROUP_IBM(fs, bestgd, &bi), 0)))
                error_msg_and_die("couldn't allocate an inode (no free inode)");
-       if(!(fs->gd[best_group].bg_free_inodes_count--))
+       GRP_PUT_GROUP_IBM(bi);
+       if(!(bestgd->bg_free_inodes_count--))
                error_msg_and_die("group descr. free blocks count == 0 (corrupted fs?)");
-       if(!(fs->sb.s_free_inodes_count--))
+       put_gd(bestgi);
+       if(!(fs->sb->s_free_inodes_count--))
                error_msg_and_die("superblock free blocks count == 0 (corrupted fs?)");
-       return fs->sb.s_inodes_per_group*best_group+nod;
+       return fs->sb->s_inodes_per_group*best_group+nod;
 }
 
 // print a bitmap allocation
@@ -962,30 +1528,40 @@
 //                               used after being freed, so once you start
 //                               freeing blocks don't stop until the end of
 //                               the file. moreover, i_blocks isn't updated.
-//                               in fact, don't do that, just use extend_blk
 // if hole!=0, create a hole in the file
 static uint32
 walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole)
 {
        uint32 *bkref = 0;
+       uint32 bk = 0;
+       blkmap_info *bmi1 = NULL, *bmi2 = NULL, *bmi3 = NULL;
        uint32 *b;
        int extend = 0, reduce = 0;
+       inode *inod;
+       nod_info *ni;
+       uint32 *iblk;
+
        if(create && (*create) < 0)
                reduce = 1;
-       if(bw->bnum >= get_nod(fs, nod)->i_blocks / INOBLK)
+       inod = get_nod(fs, nod, &ni);
+       if(bw->bnum >= inod->i_blocks / INOBLK)
        {
                if(create && (*create) > 0)
                {
                        (*create)--;
                        extend = 1;
                }
-               else    
+               else
+               {
+                       put_nod(ni);
                        return WALK_END;
+               }
        }
+       iblk = inod->i_block;
        // first direct block
        if(bw->bpdir == EXT2_INIT_BLOCK)
        {
-               bkref = &get_nod(fs, nod)->i_block[bw->bpdir = 0];
+               bkref = &iblk[bw->bpdir = 0];
                if(extend) // allocate first block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
                if(reduce) // free first block
@@ -994,7 +1570,7 @@
        // direct block
        else if(bw->bpdir < EXT2_NDIR_BLOCKS)
        {
-               bkref = &get_nod(fs, nod)->i_block[++bw->bpdir];
+               bkref = &iblk[++bw->bpdir];
                if(extend) // allocate block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
                if(reduce) // free block
@@ -1007,10 +1583,10 @@
                bw->bpdir = EXT2_IND_BLOCK;
                bw->bpind = 0;
                if(extend) // allocate indirect block
-                       get_nod(fs, nod)->i_block[bw->bpdir] = alloc_blk(fs,nod);
+                       iblk[bw->bpdir] = alloc_blk(fs,nod);
                if(reduce) // free indirect block
-                       free_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
-               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
+                       free_blk(fs, iblk[bw->bpdir]);
+               b = get_blkmap(fs, iblk[bw->bpdir], &bmi1);
                bkref = &b[bw->bpind];
                if(extend) // allocate first block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
@@ -1021,7 +1597,7 @@
        else if((bw->bpdir == EXT2_IND_BLOCK) && (bw->bpind < BLOCKSIZE/4 - 1))
        {
                bw->bpind++;
-               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
+               b = get_blkmap(fs, iblk[bw->bpdir], &bmi1);
                bkref = &b[bw->bpind];
                if(extend) // allocate block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
@@ -1036,15 +1612,15 @@
                bw->bpind = 0;
                bw->bpdind = 0;
                if(extend) // allocate double indirect block
-                       get_nod(fs, nod)->i_block[bw->bpdir] = alloc_blk(fs,nod);
+                       iblk[bw->bpdir] = alloc_blk(fs,nod);
                if(reduce) // free double indirect block
-                       free_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
-               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
+                       free_blk(fs, iblk[bw->bpdir]);
+               b = get_blkmap(fs, iblk[bw->bpdir], &bmi1);
                if(extend) // allocate first indirect block
                        b[bw->bpind] = alloc_blk(fs,nod);
                if(reduce) // free  firstindirect block
                        free_blk(fs, b[bw->bpind]);
-               b = (uint32*)get_blk(fs, b[bw->bpind]);
+               b = get_blkmap(fs, b[bw->bpind], &bmi2);
                bkref = &b[bw->bpdind];
                if(extend) // allocate first block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
@@ -1055,8 +1631,8 @@
        else if((bw->bpdir == EXT2_DIND_BLOCK) && (bw->bpdind < BLOCKSIZE/4 - 1))
        {
                bw->bpdind++;
-               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
-               b = (uint32*)get_blk(fs, b[bw->bpind]);
+               b = get_blkmap(fs, iblk[bw->bpdir], &bmi1);
+               b = get_blkmap(fs, b[bw->bpind], &bmi2);
                bkref = &b[bw->bpdind];
                if(extend) // allocate block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
@@ -1069,12 +1645,12 @@
                bw->bnum++;
                bw->bpdind = 0;
                bw->bpind++;
-               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
+               b = get_blkmap(fs, iblk[bw->bpdir], &bmi1);
                if(extend) // allocate indirect block
                        b[bw->bpind] = alloc_blk(fs,nod);
                if(reduce) // free indirect block
                        free_blk(fs, b[bw->bpind]);
-               b = (uint32*)get_blk(fs, b[bw->bpind]);
+               b = get_blkmap(fs, b[bw->bpind], &bmi2);
                bkref = &b[bw->bpdind];
                if(extend) // allocate first block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
@@ -1094,20 +1670,20 @@
                bw->bpdind = 0;
                bw->bptind = 0;
                if(extend) // allocate triple indirect block
-                       get_nod(fs, nod)->i_block[bw->bpdir] = alloc_blk(fs,nod);
+                       iblk[bw->bpdir] = alloc_blk(fs,nod);
                if(reduce) // free triple indirect block
-                       free_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
-               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
+                       free_blk(fs, iblk[bw->bpdir]);
+               b = get_blkmap(fs, iblk[bw->bpdir], &bmi1);
                if(extend) // allocate first double indirect block
                        b[bw->bpind] = alloc_blk(fs,nod);
                if(reduce) // free first double indirect block
                        free_blk(fs, b[bw->bpind]);
-               b = (uint32*)get_blk(fs, b[bw->bpind]);
+               b = get_blkmap(fs, b[bw->bpind], &bmi2);
                if(extend) // allocate first indirect block
                        b[bw->bpdind] = alloc_blk(fs,nod);
                if(reduce) // free first indirect block
                        free_blk(fs, b[bw->bpind]);
-               b = (uint32*)get_blk(fs, b[bw->bpdind]);
+               b = get_blkmap(fs, b[bw->bpdind], &bmi3);
                bkref = &b[bw->bptind];
                if(extend) // allocate first data block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
@@ -1121,9 +1697,9 @@
                  (bw->bptind < BLOCKSIZE/4 -1) )
        {
                bw->bptind++;
-               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
-               b = (uint32*)get_blk(fs, b[bw->bpind]);
-               b = (uint32*)get_blk(fs, b[bw->bpdind]);
+               b = get_blkmap(fs, iblk[bw->bpdir], &bmi1);
+               b = get_blkmap(fs, b[bw->bpind], &bmi2);
+               b = get_blkmap(fs, b[bw->bpdind], &bmi3);
                bkref = &b[bw->bptind];
                if(extend) // allocate data block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
@@ -1140,13 +1716,13 @@
                bw->bnum++;
                bw->bptind = 0;
                bw->bpdind++;
-               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
-               b = (uint32*)get_blk(fs, b[bw->bpind]);
+               b = get_blkmap(fs, iblk[bw->bpdir], &bmi1);
+               b = get_blkmap(fs, b[bw->bpind], &bmi2);
                if(extend) // allocate single indirect block
                        b[bw->bpdind] = alloc_blk(fs,nod);
                if(reduce) // free indirect block
                        free_blk(fs, b[bw->bpind]);
-               b = (uint32*)get_blk(fs, b[bw->bpdind]);
+               b = get_blkmap(fs, b[bw->bpdind], &bmi3);
                bkref = &b[bw->bptind];
                if(extend) // allocate first data block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
@@ -1163,17 +1739,17 @@
                bw->bpdind = 0;
                bw->bptind = 0;
                bw->bpind++;
-               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
+               b = get_blkmap(fs, iblk[bw->bpdir], &bmi1);
                if(extend) // allocate double indirect block
                        b[bw->bpind] = alloc_blk(fs,nod);
                if(reduce) // free double indirect block
                        free_blk(fs, b[bw->bpind]);
-               b = (uint32*)get_blk(fs, b[bw->bpind]);
+               b = get_blkmap(fs, b[bw->bpind], &bmi2);
                if(extend) // allocate single indirect block
                        b[bw->bpdind] = alloc_blk(fs,nod);
                if(reduce) // free indirect block
                        free_blk(fs, b[bw->bpind]);
-               b = (uint32*)get_blk(fs, b[bw->bpdind]);
+               b = get_blkmap(fs, b[bw->bpdind], &bmi3);
                bkref = &b[bw->bptind];
                if(extend) // allocate first block
                        *bkref = hole ? 0 : alloc_blk(fs,nod);
@@ -1184,56 +1760,105 @@
                error_msg_and_die("file too big !"); 
        /* End change for walking triple indirection */
 
-       if(*bkref)
-       {
+       bk = *bkref;
+       if (bmi3)
+               put_blkmap(bmi3);
+       if (bmi2)
+               put_blkmap(bmi2);
+       if (bmi1)
+               put_blkmap(bmi1);
+
+       if(bk)
+       {
+               blk_info *bi;
+               gd_info *gi;
+               uint8 *block;
                bw->bnum++;
-               if(!reduce && !allocated(GRP_GET_BLOCK_BITMAP(fs,*bkref), GRP_BBM_OFFSET(fs,*bkref)))
-                       error_msg_and_die("[block %d of inode %d is unallocated !]", *bkref, nod);
+               block = GRP_GET_BLOCK_BITMAP(fs,bk,&bi,&gi);
+               if(!reduce && !allocated(block, GRP_BBM_OFFSET(fs,bk)))
+                       error_msg_and_die("[block %d of inode %d is unallocated !]", bk, nod);
+               GRP_PUT_BLOCK_BITMAP(bi, gi);
        }
        if(extend)
-               get_nod(fs, nod)->i_blocks = bw->bnum * INOBLK;
-       return *bkref;
+               inod->i_blocks = bw->bnum * INOBLK;
+       put_nod(ni);
+       return bk;
 }
 
-// add blocks to an inode (file/dir/etc...)
-static void
-extend_blk(filesystem *fs, uint32 nod, block b, int amount)
+typedef struct
 {
-       int create = amount;
-       blockwalker bw, lbw;
-       uint32 bk;
-       init_bw(&bw);
-       if(amount < 0)
-       {
-               uint32 i;
-               for(i = 0; i < get_nod(fs, nod)->i_blocks / INOBLK + amount; i++)
-                       walk_bw(fs, nod, &bw, 0, 0);
-               while(walk_bw(fs, nod, &bw, &create, 0) != WALK_END)
+       blockwalker bw;
+       uint32 nod;
+       nod_info *ni;
+       inode *inod;
+} inode_pos;
+#define INODE_POS_TRUNCATE 0
+#define INODE_POS_EXTEND 1
+
+// Call this to set up an ipos structure for future use with
+// extend_inode_blk to append blocks to the given inode.  If
+// op is INODE_POS_TRUNCATE, the inode is truncated to zero size.
+// If op is INODE_POS_EXTEND, the position is moved to the end
+// of the inode's data blocks.
+// Call inode_pos_finish when done with the inode_pos structure.
+static void
+inode_pos_init(filesystem *fs, inode_pos *ipos, uint32 nod, int op,
+              blockwalker *endbw)
+{
+       blockwalker lbw;
+
+       init_bw(&ipos->bw);
+       ipos->nod = nod;
+       ipos->inod = get_nod(fs, nod, &ipos->ni);
+       if (op == INODE_POS_TRUNCATE) {
+               int32 create = -1;
+               while(walk_bw(fs, nod, &ipos->bw, &create, 0) != WALK_END)
                        /*nop*/;
-               get_nod(fs, nod)->i_blocks += amount * INOBLK;
+               ipos->inod->i_blocks = 0;
        }
-       else
+
+       if (endbw)
+               ipos->bw = *endbw;
+       else {
+               /* Seek to the end */
+               init_bw(&ipos->bw);
+               lbw = ipos->bw;
+               while(walk_bw(fs, nod, &ipos->bw, 0, 0) != WALK_END)
+                       lbw = ipos->bw;
+               ipos->bw = lbw;
+       }
+}
+
+// Clean up the inode_pos structure.
+static void
+inode_pos_finish(filesystem *fs, inode_pos *ipos)
+{
+       put_nod(ipos->ni);
+}
+
+// add blocks to an inode (file/dir/etc...) at the given position.
+// This will only work when appending to the end of an inode.
+static void
+extend_inode_blk(filesystem *fs, inode_pos *ipos, block b, int amount)
+{
+       uint32 bk;
+       uint32 pos;
+
+       if (amount < 0)
+               error_msg_and_die("extend_inode_blk: Got negative amount");
+
+       for (pos = 0; amount; pos += BLOCKSIZE)
        {
-               lbw = bw;
-               while((bk = walk_bw(fs, nod, &bw, 0, 0)) != WALK_END)
-                       lbw = bw;
-               bw = lbw;
-               while(create)
-               {
-                       int i, copyb = 0;
-                       if(!(fs->sb.s_reserved[200] & OP_HOLES))
-                               copyb = 1;
-                       else
-                               for(i = 0; i < BLOCKSIZE / 4; i++)
-                                       if(((int32*)(b + BLOCKSIZE * (amount - create)))[i])
-                                       {
-                                               copyb = 1;
-                                               break;
-                                       }
-                       if((bk = walk_bw(fs, nod, &bw, &create, !copyb)) == WALK_END)
-                               break;
-                       if(copyb)
-                               memcpy(get_blk(fs, bk), b + BLOCKSIZE * (amount - create - 1), BLOCKSIZE);
+               int hole = (fs->holes && is_blk_empty(b + pos));
+
+               bk = walk_bw(fs, ipos->nod, &ipos->bw, &amount, hole);
+               if (bk == WALK_END)
+                       error_msg_and_die("extend_inode_blk: extend failed");
+               if (!hole) {
+                       blk_info *bi;
+                       uint8 *block = get_blk(fs, bk, &bi);
+                       memcpy(block, b + pos, BLOCKSIZE);
+                       put_blk(bi);
                }
        }
 }
@@ -1242,15 +1867,17 @@
 static void
 add2dir(filesystem *fs, uint32 dnod, uint32 nod, const char* name)
 {
-       blockwalker bw;
+       blockwalker bw, lbw;
        uint32 bk;
-       uint8 *b;
        directory *d;
+       dirwalker dw;
        int reclen, nlen;
        inode *node;
        inode *pnode;
+       nod_info *dni, *ni;
+       inode_pos ipos;
 
-       pnode = get_nod(fs, dnod);
+       pnode = get_nod(fs, dnod, &dni);
        if((pnode->i_mode & FM_IFMT) != FM_IFDIR)
                error_msg_and_die("can't add '%s' to a non-directory", name);
        if(!*name)
@@ -1262,52 +1889,52 @@
        if(reclen > BLOCKSIZE)
                error_msg_and_die("bad name '%s' (too long)", name);
        init_bw(&bw);
+       lbw = bw;
        while((bk = walk_bw(fs, dnod, &bw, 0, 0)) != WALK_END) // for all blocks in dir
        {
-               b = get_blk(fs, bk);
                // for all dir entries in block
-               for(d = (directory*)b; (int8*)d + sizeof(*d) < (int8*)b + BLOCKSIZE; d = (directory*)((int8*)d + d->d_rec_len))
+               for(d = get_dir(fs, bk, &dw); d; d = next_dir(&dw))
                {
                        // if empty dir entry, large enough, use it
                        if((!d->d_inode) && (d->d_rec_len >= reclen))
                        {
                                d->d_inode = nod;
-                               node = get_nod(fs, nod);
+                               node = get_nod(fs, nod, &ni);
+                               dir_set_name(&dw, name, nlen);
+                               put_dir(&dw);
                                node->i_links_count++;
-                               d->d_name_len = nlen;
-                               strncpy(d->d_name, name, nlen);
-                               return;
+                               put_nod(ni);
+                               goto out;
                        }
                        // if entry with enough room (last one?), shrink it & use it
                        if(d->d_rec_len >= (sizeof(directory) + rndup(d->d_name_len, 4) + reclen))
                        {
-                               reclen = d->d_rec_len;
-                               d->d_rec_len = sizeof(directory) + rndup(d->d_name_len, 4);
-                               reclen -= d->d_rec_len;
-                               d = (directory*) (((int8*)d) + d->d_rec_len);
-                               d->d_rec_len = reclen;
-                               d->d_inode = nod;
-                               node = get_nod(fs, nod);
+                               d = shrink_dir(&dw, nod, name, nlen);
+                               put_dir(&dw);
+                               node = get_nod(fs, nod, &ni);
                                node->i_links_count++;
-                               d->d_name_len = nlen;
-                               strncpy(d->d_name, name, nlen);
-                               return;
+                               put_nod(ni);
+                               goto out;
                        }
                }
+               put_dir(&dw);
+               lbw = bw;
        }
        // we found no free entry in the directory, so we add a block
-       if(!(b = get_workblk()))
-               error_msg_and_die("get_workblk() failed.");
-       d = (directory*)b;
-       d->d_inode = nod;
-       node = get_nod(fs, nod);
+       node = get_nod(fs, nod, &ni);
+       d = new_dir(fs, nod, name, nlen, &dw);
        node->i_links_count++;
-       d->d_rec_len = BLOCKSIZE;
-       d->d_name_len = nlen;
-       strncpy(d->d_name, name, nlen);
-       extend_blk(fs, dnod, b, 1);
-       get_nod(fs, dnod)->i_size += BLOCKSIZE;
-       free_workblk(b);
+       put_nod(ni);
+       next_dir(&dw); // Force the data into the buffer
+
+       inode_pos_init(fs, &ipos, dnod, INODE_POS_EXTEND, &lbw);
+       extend_inode_blk(fs, &ipos, dir_data(&dw), 1);
+       inode_pos_finish(fs, &ipos);
+
+       put_dir(&dw);
+       pnode->i_size += BLOCKSIZE;
+out:
+       put_nod(dni);
 }
 
 // find an entry in a directory
@@ -1321,11 +1948,13 @@
        while((bk = walk_bw(fs, nod, &bw, 0, 0)) != WALK_END)
        {
                directory *d;
-               uint8 *b;
-               b = get_blk(fs, bk);
-               for(d = (directory*)b; (int8*)d + sizeof(*d) < (int8*)b + BLOCKSIZE; d = (directory*)((int8*)d + d->d_rec_len))
-                       if(d->d_inode && (nlen == d->d_name_len) && !strncmp(d->d_name, name, nlen))
+               dirwalker dw;
+               for (d = get_dir(fs, bk, &dw); d; d=next_dir(&dw))
+                       if(d->d_inode && (nlen == d->d_name_len) && !strncmp(dir_name(&dw), name, nlen)) {
+                               put_dir(&dw);
                                return d->d_inode;
+                       }
+               put_dir(&dw);
        }
        return 0;
 }
@@ -1356,47 +1985,55 @@
        return nod;
 }
 
+// chmod an inode
+void
+chmod_fs(filesystem *fs, uint32 nod, uint16 mode, uint16 uid, uint16 gid)
+{
+       inode *node;
+       nod_info *ni;
+       node = get_nod(fs, nod, &ni);
+       node->i_mode = (node->i_mode & ~FM_IMASK) | (mode & FM_IMASK);
+       node->i_uid = uid;
+       node->i_gid = gid;
+       put_nod(ni);
+}
+
 // create a simple inode
 static uint32
 mknod_fs(filesystem *fs, uint32 parent_nod, const char *name, uint16 mode, uint16 uid, uint16 gid, uint8 major, uint8 minor, uint32 ctime, uint32 mtime)
 {
        uint32 nod;
        inode *node;
-       if((nod = find_dir(fs, parent_nod, name)))
-       {
-               node = get_nod(fs, nod);
-               if((node->i_mode & FM_IFMT) != (mode & FM_IFMT))
-                       error_msg_and_die("node '%s' already exists and isn't of the same type", name);
-               node->i_mode = mode;
-       }
-       else
+       nod_info *ni;
+       gd_info *gi;
+
+       nod = alloc_nod(fs);
+       node = get_nod(fs, nod, &ni);
+       node->i_mode = mode;
+       add2dir(fs, parent_nod, nod, name);
+       switch(mode & FM_IFMT)
        {
-               nod = alloc_nod(fs);
-               node = get_nod(fs, nod);
-               node->i_mode = mode;
-               add2dir(fs, parent_nod, nod, name);
-               switch(mode & FM_IFMT)
-               {
-                       case FM_IFLNK:
-                               mode = FM_IFLNK | FM_IRWXU | FM_IRWXG | FM_IRWXO;
-                               break;
-                       case FM_IFBLK:
-                       case FM_IFCHR:
-                               ((uint8*)get_nod(fs, nod)->i_block)[0] = minor;
-                               ((uint8*)get_nod(fs, nod)->i_block)[1] = major;
-                               break;
-                       case FM_IFDIR:
-                               add2dir(fs, nod, nod, ".");
-                               add2dir(fs, nod, parent_nod, "..");
-                               fs->gd[GRP_GROUP_OF_INODE(fs,nod)].bg_used_dirs_count++;
-                               break;
-               }
+       case FM_IFLNK:
+               mode = FM_IFLNK | FM_IRWXU | FM_IRWXG | FM_IRWXO;
+               break;
+       case FM_IFBLK:
+       case FM_IFCHR:
+               ((uint8*)node->i_block)[0] = minor;
+               ((uint8*)node->i_block)[1] = major;
+               break;
+       case FM_IFDIR:
+               add2dir(fs, nod, nod, ".");
+               add2dir(fs, nod, parent_nod, "..");
+               get_gd(fs,GRP_GROUP_OF_INODE(fs,nod),&gi)->bg_used_dirs_count++;
+               put_gd(gi);
+               break;
        }
        node->i_uid = uid;
        node->i_gid = gid;
        node->i_atime = mtime;
        node->i_ctime = ctime;
        node->i_mtime = mtime;
+       put_nod(ni);
        return nod;
 }
 
@@ -1413,33 +2050,73 @@
 mklink_fs(filesystem *fs, uint32 parent_nod, const char *name, size_t size, uint8 *b, uid_t uid, gid_t gid, uint32 ctime, uint32 mtime)
 {
        uint32 nod = mknod_fs(fs, parent_nod, name, FM_IFLNK | FM_IRWXU | FM_IRWXG | FM_IRWXO, uid, gid, 0, 0, ctime, mtime);
-       extend_blk(fs, nod, 0, - (int)get_nod(fs, nod)->i_blocks / INOBLK);
-       get_nod(fs, nod)->i_size = size;
-       if(size <= 4 * (EXT2_TIND_BLOCK+1))
-       {
-               strncpy((char*)get_nod(fs, nod)->i_block, (char*)b, size);
+       nod_info *ni;
+       inode *node = get_nod(fs, nod, &ni);
+       inode_pos ipos;
+
+       inode_pos_init(fs, &ipos, nod, INODE_POS_TRUNCATE, NULL);
+       node->i_size = size;
+       if(size < 4 * (EXT2_TIND_BLOCK+1))
+       {
+               strncpy((char*)node->i_block, (char*)b, size);
+               ((char*)node->i_block)[size+1] = '\0';
+               inode_pos_finish(fs, &ipos);
+               put_nod(ni);
                return nod;
        }
-       extend_blk(fs, nod, b, rndup(size, BLOCKSIZE) / BLOCKSIZE);
+       extend_inode_blk(fs, &ipos, b, rndup(size, BLOCKSIZE) / BLOCKSIZE);
+       inode_pos_finish(fs, &ipos);
+       put_nod(ni);
        return nod;
 }
 
+static void
+fs_upgrade_rev1_largefile(filesystem *fs)
+{
+       fs->sb->s_rev_level = 1;
+       fs->sb->s_first_ino = EXT2_GOOD_OLD_FIRST_INO;
+       fs->sb->s_inode_size = EXT2_GOOD_OLD_INODE_SIZE;
+}
+
+#define COPY_BLOCKS 16
+#define CB_SIZE (COPY_BLOCKS * BLOCKSIZE)
+
 // make a file from a FILE*
 static uint32
-mkfile_fs(filesystem *fs, uint32 parent_nod, const char *name, uint32 mode, size_t size, FILE *f, uid_t uid, gid_t gid, uint32 ctime, uint32 mtime)
+mkfile_fs(filesystem *fs, uint32 parent_nod, const char *name, uint32 mode, FILE *f, uid_t uid, gid_t gid, uint32 ctime, uint32 mtime)
 {
        uint8 * b;
        uint32 nod = mknod_fs(fs, parent_nod, name, mode|FM_IFREG, uid, gid, 0, 0, ctime, mtime);
-       extend_blk(fs, nod, 0, - (int)get_nod(fs, nod)->i_blocks / INOBLK);
-       get_nod(fs, nod)->i_size = size;
-       if (size) {
-               if(!(b = (uint8*)calloc(rndup(size, BLOCKSIZE), 1)))
-                       error_msg_and_die("not enough mem to read file '%s'", name);
-               if(f)
-                       fread(b, size, 1, f); // FIXME: ugly. use mmap() ...
-               extend_blk(fs, nod, b, rndup(size, BLOCKSIZE) / BLOCKSIZE);
-               free(b);
-       }
+       nod_info *ni;
+       inode *node = get_nod(fs, nod, &ni);
+       off_t size = 0;
+       size_t readbytes;
+       inode_pos ipos;
+       int fullsize;
+
+       b = malloc(CB_SIZE);
+       if (!b)
+               error_msg_and_die("mkfile_fs: out of memory");
+       inode_pos_init(fs, &ipos, nod, INODE_POS_TRUNCATE, NULL);
+       readbytes = fread(b, 1, CB_SIZE, f);
+       while (readbytes) {
+               fullsize = rndup(readbytes, BLOCKSIZE);
+               // Fill to end of block with zeros.
+               memset(b + readbytes, 0, fullsize - readbytes);
+               extend_inode_blk(fs, &ipos, b, fullsize / BLOCKSIZE);
+               size += readbytes;
+               readbytes = fread(b, 1, CB_SIZE, f);
+       }
+       if (size > 0x7fffffff) {
+               if (fs->sb->s_rev_level < 1)
+                       fs_upgrade_rev1_largefile(fs);
+               fs->sb->s_feature_ro_compat |= EXT2_FEATURE_RO_COMPAT_LARGE_FILE;
+       }
+       node->i_dir_acl = size >> 32;
+       node->i_size = size;
+       inode_pos_finish(fs, &ipos);
+       put_nod(ni);
+       free(b);
        return nod;
 }
 
@@ -1591,13 +2268,24 @@
                                dname = malloc(len + 1);
                                for(i = start; i < count; i++)
                                {
+                                       uint32 oldnod;
                                        SNPRINTF(dname, len, "%s%lu", name, i);
-                                       mknod_fs(fs, nod, dname, mode, uid, gid, major, minor + (i * increment - start), ctime, mtime);
+                                       oldnod = find_dir(fs, nod, dname);
+                                       if(oldnod)
+                                               chmod_fs(fs, oldnod, mode, uid, gid);
+                                       else
+                                               mknod_fs(fs, nod, dname, mode, uid, gid, major, minor + (i * increment - start), ctime, mtime);
                                }
                                free(dname);
                        }
                        else
-                               mknod_fs(fs, nod, name, mode, uid, gid, major, minor, ctime, mtime);
+                       {
+                               uint32 oldnod = find_dir(fs, nod, name);
+                               if(oldnod)
+                                       chmod_fs(fs, oldnod, mode, uid, gid);
+                               else
+                                       mknod_fs(fs, nod, name, mode, uid, gid, major, minor, ctime, mtime);
+                       }
                }
        }
        if (line)
@@ -1643,6 +2331,10 @@
                        switch(st.st_mode & S_IFMT)
                        {
                                case S_IFLNK:
+                                       if((st.st_mode & S_IFMT) == S_IFREG || st.st_size >= 4 * (EXT2_TIND_BLOCK+1))
+                                               stats->nblocks += (st.st_size + BLOCKSIZE - 1) / BLOCKSIZE;
+                                       stats->ninodes++;
+                                       break;
                                case S_IFREG:
                                        if((st.st_mode & S_IFMT) == S_IFREG || st.st_size > 4 * (EXT2_TIND_BLOCK+1))
                                                stats->nblocks += (st.st_size + BLOCKSIZE - 1) / BLOCKSIZE;
@@ -1657,19 +2349,33 @@
                                        if(chdir(dent->d_name) < 0)
                                                perror_msg_and_die(dent->d_name);
                                        add2fs_from_dir(fs, this_nod, squash_uids, squash_perms, fs_timestamp, stats);
-                                       chdir("..");
+                                       if (chdir("..") == -1)
+                                               perror_msg_and_die("..");
+
                                        break;
                                default:
                                        break;
                        }
                else
                {
+                       if((nod = find_dir(fs, this_nod, name)))
+                       {
+                               error_msg("ignoring duplicate entry %s", name);
+                               if(S_ISDIR(st.st_mode)) {
+                                       if(chdir(dent->d_name) < 0)
+                                               perror_msg_and_die(name);
+                                       add2fs_from_dir(fs, nod, squash_uids, squash_perms, fs_timestamp, stats);
+                                       if (chdir("..") == -1)
+                                               perror_msg_and_die("..");
+                               }
+                               continue;
+                       }
                        save_nod = 0;
                        /* Check for hardlinks */
                        if (!S_ISDIR(st.st_mode) && !S_ISLNK(st.st_mode) && st.st_nlink > 1) {
-                               int32 hdlink = is_hardlink(st.st_ino);
+                               int32 hdlink = is_hardlink(fs, st.st_ino);
                                if (hdlink >= 0) {
-                                       add2dir(fs, this_nod, hdlinks.hdl[hdlink].dst_nod, name);
+                                       add2dir(fs, this_nod, fs->hdlinks.hdl[hdlink].dst_nod, name);
                                        continue;
                                } else {
                                        save_nod = 1;
@@ -1697,8 +2403,12 @@
                                        free(lnk);
                                        break;
                                case S_IFREG:
-                                       fh = xfopen(dent->d_name, "rb");
-                                       nod = mkfile_fs(fs, this_nod, name, mode, st.st_size, fh, uid, gid, ctime, mtime);
+                                       fh = fopen(dent->d_name, "rb");
+                                       if (!fh) {
+                                               error_msg("Unable to open file %s", dent->d_name);
+                                               break;
+                                       }
+                                       nod = mkfile_fs(fs, this_nod, name, mode, fh, uid, gid, ctime, mtime);
                                        fclose(fh);
                                        break;
                                case S_IFDIR:
@@ -1706,199 +2416,128 @@
                                        if(chdir(dent->d_name) < 0)
                                                perror_msg_and_die(name);
                                        add2fs_from_dir(fs, nod, squash_uids, squash_perms, fs_timestamp, stats);
-                                       chdir("..");
+                                       if (chdir("..") == -1)
+                                               perror_msg_and_die("..");
                                        break;
                                default:
                                        error_msg("ignoring entry %s", name);
                        }
                        if (save_nod) {
-                               if (hdlinks.count == hdlink_cnt) {
-                                       if ((hdlinks.hdl = 
-                                                realloc (hdlinks.hdl, (hdlink_cnt + HDLINK_CNT) *
+                               if (fs->hdlinks.count == fs->hdlink_cnt) {
+                                       if ((fs->hdlinks.hdl =
+                                                realloc (fs->hdlinks.hdl, (fs->hdlink_cnt + HDLINK_CNT) *
                                                                  sizeof (struct hdlink_s))) == NULL) {
                                                error_msg_and_die("Not enough memory");
                                        }
-                                       hdlink_cnt += HDLINK_CNT;
+                                       fs->hdlink_cnt += HDLINK_CNT;
                                }
-                               hdlinks.hdl[hdlinks.count].src_inode = st.st_ino;
-                               hdlinks.hdl[hdlinks.count].dst_nod = nod;
-                               hdlinks.count++;
+                               fs->hdlinks.hdl[fs->hdlinks.count].src_inode = st.st_ino;
+                               fs->hdlinks.hdl[fs->hdlinks.count].dst_nod = nod;
+                               fs->hdlinks.count++;
                        }
                }
        }
        closedir(dh);
 }
 
-// endianness swap of x-indirect blocks
+// Copy size blocks from src to dst, putting holes in the output
+// file (if possible) if the input block is all zeros.
+// Copy size blocks from src to dst, putting holes in the output
+// file (if possible) if the input block is all zeros.
 static void
-swap_goodblocks(filesystem *fs, inode *nod)
+copy_file(filesystem *fs, FILE *dst, FILE *src, size_t size)
 {
-       uint32 i,j;
-       int done=0;
-       uint32 *b,*b2;
+       uint8 *b;
 
-       uint32 nblk = nod->i_blocks / INOBLK;
-       if((nod->i_size && !nblk) || ((nod->i_mode & FM_IFBLK) == FM_IFBLK) || ((nod->i_mode & FM_IFCHR) == FM_IFCHR))
-               for(i = 0; i <= EXT2_TIND_BLOCK; i++)
-                       nod->i_block[i] = swab32(nod->i_block[i]);
-       if(nblk <= EXT2_IND_BLOCK)
-               return;
-       swap_block(get_blk(fs, nod->i_block[EXT2_IND_BLOCK]));
-       if(nblk <= EXT2_DIND_BLOCK + BLOCKSIZE/4)
-               return;
-       /* Currently this will fail b'cos the number of blocks as stored
-          in i_blocks also includes the indirection blocks (see
-          walk_bw). But this function assumes that i_blocks only
-          stores the count of data blocks ( Actually according to
-          "Understanding the Linux Kernel" (Table 17-3 p502 1st Ed)
-          i_blocks IS supposed to store the count of data blocks). so
-          with a file of size 268K nblk would be 269.The above check
-          will be false even though double indirection hasn't been
-          started.This is benign as 0 means block 0 which has been
-          zeroed out and therefore points back to itself from any offset
-        */
-       // FIXME: I have fixed that, but I have the feeling the rest of
-       // ths function needs to be fixed for the same reasons - Xav
-       assert(nod->i_block[EXT2_DIND_BLOCK] != 0);
-       for(i = 0; i < BLOCKSIZE/4; i++)
-               if(nblk > EXT2_IND_BLOCK + BLOCKSIZE/4 + (BLOCKSIZE/4)*i )
-                       swap_block(get_blk(fs, ((uint32*)get_blk(fs, nod->i_block[EXT2_DIND_BLOCK]))[i]));
-       swap_block(get_blk(fs, nod->i_block[EXT2_DIND_BLOCK]));
-       if(nblk <= EXT2_IND_BLOCK + BLOCKSIZE/4 + BLOCKSIZE/4 * BLOCKSIZE/4)
-               return;
-       /* Adding support for triple indirection */
-       b = (uint32*)get_blk(fs,nod->i_block[EXT2_TIND_BLOCK]);
-       for(i=0;i < BLOCKSIZE/4 && !done ; i++) {
-               b2 = (uint32*)get_blk(fs,b[i]); 
-               for(j=0; j<BLOCKSIZE/4;j++) {
-                       if (nblk > ( EXT2_IND_BLOCK + BLOCKSIZE/4 + 
-                                    (BLOCKSIZE/4)*(BLOCKSIZE/4) + 
-                                    i*(BLOCKSIZE/4)*(BLOCKSIZE/4) + 
-                                    j*(BLOCKSIZE/4)) ) 
-                         swap_block(get_blk(fs,b2[j]));
-                       else {
-                         done = 1;
-                         break;
-                       }
+       b = malloc(BLOCKSIZE);
+       if (!b)
+               error_msg_and_die("copy_file: out of memory");
+       if (fseek(src, 0, SEEK_SET))
+               perror_msg_and_die("fseek");
+       if (ftruncate(fileno(dst), 0))
+               perror_msg_and_die("copy_file: ftruncate");
+       while (size > 0) {
+               if (fread(b, BLOCKSIZE, 1, src) != 1)
+                       perror_msg_and_die("copy failed on read");
+               if ((dst != stdout) && fs->holes && is_blk_empty(b)) {
+                       /* Empty block, just skip it */
+                       if (fseek(dst, BLOCKSIZE, SEEK_CUR))
+                               perror_msg_and_die("fseek");
+               } else {
+                       if (fwrite(b, BLOCKSIZE, 1, dst) != 1)
+                               perror_msg_and_die("copy failed on write");
                }
-               swap_block((uint8 *)b2);
+               size--;
        }
-       swap_block((uint8 *)b);
-       return;
+       free(b);
 }
 
-static void
-swap_badblocks(filesystem *fs, inode *nod)
+// Allocate a new filesystem structure, allocate internal memory,
+// and initialize the contents.
+static filesystem *
+alloc_fs(int swapit, char *fname, uint32 nbblocks, FILE *srcfile)
 {
-       uint32 i,j;
-       int done=0;
-       uint32 *b,*b2;
+       filesystem *fs;
+       struct stat srcstat, dststat;
 
-       uint32 nblk = nod->i_blocks / INOBLK;
-       if((nod->i_size && !nblk) || ((nod->i_mode & FM_IFBLK) == FM_IFBLK) || ((nod->i_mode & FM_IFCHR) == FM_IFCHR))
-               for(i = 0; i <= EXT2_TIND_BLOCK; i++)
-                       nod->i_block[i] = swab32(nod->i_block[i]);
-       if(nblk <= EXT2_IND_BLOCK)
-               return;
-       swap_block(get_blk(fs, nod->i_block[EXT2_IND_BLOCK]));
-       if(nblk <= EXT2_DIND_BLOCK + BLOCKSIZE/4)
-               return;
-       /* See comment in swap_goodblocks */
-       assert(nod->i_block[EXT2_DIND_BLOCK] != 0);
-       swap_block(get_blk(fs, nod->i_block[EXT2_DIND_BLOCK]));
-       for(i = 0; i < BLOCKSIZE/4; i++)
-               if(nblk > EXT2_IND_BLOCK + BLOCKSIZE/4 + (BLOCKSIZE/4)*i )
-                       swap_block(get_blk(fs, ((uint32*)get_blk(fs, nod->i_block[EXT2_DIND_BLOCK]))[i]));
-       if(nblk <= EXT2_IND_BLOCK + BLOCKSIZE/4 + BLOCKSIZE/4 * BLOCKSIZE/4)
-               return;
-       /* Adding support for triple indirection */
-       b = (uint32*)get_blk(fs,nod->i_block[EXT2_TIND_BLOCK]);
-       swap_block((uint8 *)b);
-       for(i=0;i < BLOCKSIZE/4 && !done ; i++) {
-               b2 = (uint32*)get_blk(fs,b[i]); 
-               swap_block((uint8 *)b2);
-               for(j=0; j<BLOCKSIZE/4;j++) {
-                       if (nblk > ( EXT2_IND_BLOCK + BLOCKSIZE/4 + 
-                                    (BLOCKSIZE/4)*(BLOCKSIZE/4) + 
-                                    i*(BLOCKSIZE/4)*(BLOCKSIZE/4) + 
-                                    j*(BLOCKSIZE/4)) ) 
-                         swap_block(get_blk(fs,b2[j]));
-                       else {
-                         done = 1;
-                         break;
-                       }
-               }
-       }
-       return;
-}
+       fs = malloc(sizeof(*fs));
+       if (!fs)
+               error_msg_and_die("not enough memory for filesystem");
+       memset(fs, 0, sizeof(*fs));
+       fs->swapit = swapit;
+       cache_init(&fs->blks, MAX_FREE_CACHE_BLOCKS, blk_elem_val, blk_freed);
+       cache_init(&fs->gds, MAX_FREE_CACHE_GDS, gd_elem_val, gd_freed);
+       cache_init(&fs->blkmaps, MAX_FREE_CACHE_BLOCKMAPS,
+                  blkmap_elem_val, blkmap_freed);
+       cache_init(&fs->inodes, MAX_FREE_CACHE_INODES,
+                  inode_elem_val, inode_freed);
+       fs->hdlink_cnt = HDLINK_CNT;
+       fs->hdlinks.hdl = calloc(sizeof(struct hdlink_s), fs->hdlink_cnt);
+       if (!fs->hdlinks.hdl)
+               error_msg_and_die("Not enough memory");
+       fs->hdlinks.count = 0 ;
 
-// endianness swap of the whole filesystem
-static void
-swap_goodfs(filesystem *fs)
-{
-       uint32 i;
-       for(i = 1; i < fs->sb.s_inodes_count; i++)
-       {
-               inode *nod = get_nod(fs, i);
-               if(nod->i_mode & FM_IFDIR)
-               {
-                       blockwalker bw;
-                       uint32 bk;
-                       init_bw(&bw);
-                       while((bk = walk_bw(fs, i, &bw, 0, 0)) != WALK_END)
-                       {
-                               directory *d;
-                               uint8 *b;
-                               b = get_blk(fs, bk);
-                               for(d = (directory*)b; (int8*)d + sizeof(*d) < (int8*)b + BLOCKSIZE; d = (directory*)((int8*)d + swab16(d->d_rec_len)))
-                                       swap_dir(d);
-                       }
-               }
-               swap_goodblocks(fs, nod);
-               swap_nod(nod);
-       }
-       for(i=0;i<GRP_NBGROUPS(fs);i++)
-               swap_gd(&(fs->gd[i]));
-       swap_sb(&fs->sb);
+       if (strcmp(fname, "-") == 0)
+               fs->f = tmpfile();
+       else if (srcfile) {
+               if (fstat(fileno(srcfile), &srcstat))
+                       perror_msg_and_die("fstat srcfile");
+               if (stat(fname, &dststat) == 0
+                   && srcstat.st_ino == dststat.st_ino
+                   && srcstat.st_dev == dststat.st_dev)
+                 {
+                       // source and destination are the same file, don't
+                       // truncate or copy, just use the file.
+                       fs->f = fopen(fname, "r+b");
+               } else {
+                       fs->f = fopen(fname, "w+b");
+                       if (fs->f)
+                               copy_file(fs, fs->f, srcfile, nbblocks);
+               }
+       } else
+               fs->f = fopen(fname, "w+b");
+       if (!fs->f)
+               perror_msg_and_die("opening %s", fname);
+       return fs;
 }
 
+/* Make sure the output file is the right size */
 static void
-swap_badfs(filesystem *fs)
+set_file_size(filesystem *fs)
 {
-       uint32 i;
-       swap_sb(&fs->sb);
-       for(i=0;i<GRP_NBGROUPS(fs);i++)
-               swap_gd(&(fs->gd[i]));
-       for(i = 1; i < fs->sb.s_inodes_count; i++)
-       {
-               inode *nod = get_nod(fs, i);
-               swap_nod(nod);
-               swap_badblocks(fs, nod);
-               if(nod->i_mode & FM_IFDIR)
-               {
-                       blockwalker bw;
-                       uint32 bk;
-                       init_bw(&bw);
-                       while((bk = walk_bw(fs, i, &bw, 0, 0)) != WALK_END)
-                       {
-                               directory *d;
-                               uint8 *b;
-                               b = get_blk(fs, bk);
-                               for(d = (directory*)b; (int8*)d + sizeof(*d) < (int8*)b + BLOCKSIZE; d = (directory*)((int8*)d + d->d_rec_len))
-                                       swap_dir(d);
-                       }
-               }
-       }
+       if (ftruncate(fileno(fs->f),
+                     ((off_t) fs->sb->s_blocks_count) * BLOCKSIZE))
+               perror_msg_and_die("set_file_size: ftruncate");
 }
 
 // initialize an empty filesystem
 static filesystem *
-init_fs(int nbblocks, int nbinodes, int nbresrvd, int holes, uint32 fs_timestamp)
+init_fs(int nbblocks, int nbinodes, int nbresrvd, int holes,
+       uint32 fs_timestamp, uint32 creator_os, int swapit, char *fname)
 {
        uint32 i;
        filesystem *fs;
-       directory *d;
-       uint8 * b;
+       dirwalker dw;
        uint32 nod, first_block;
        uint32 nbgroups,nbinodes_per_group,overhead_per_group,free_blocks,
                free_blocks_per_group,nbblocks_per_group,min_nbgroups;
@@ -1906,6 +2545,11 @@
        uint32 j;
        uint8 *bbm,*ibm;
        inode *itab0;
+       blk_info *bi;
+       nod_info *ni;
+       groupdescriptor *gd;
+       gd_info *gi;
+       inode_pos ipos;
        
        if(nbresrvd < 0)
                error_msg_and_die("reserved blocks value is invalid. Note: options have changed, see --help or the man page.");
@@ -1919,10 +2563,14 @@
         */
        min_nbgroups = (nbinodes + INODES_PER_GROUP - 1) / INODES_PER_GROUP;
 
+       /* On filesystems with 1k block size, the bootloader area uses a full
+        * block. For 2048 and up, the superblock can be fitted into block 0.
+        */
+       first_block = (BLOCKSIZE == 1024);
+
        /* nbblocks is the total number of blocks in the filesystem.
         * a block group can have no more than 8192 blocks.
         */
-       first_block = (BLOCKSIZE == 1024);
        nbgroups = (nbblocks - first_block + BLOCKS_PER_GROUP - 1) / BLOCKS_PER_GROUP;
        if(nbgroups < min_nbgroups) nbgroups = min_nbgroups;
        nbblocks_per_group = rndup((nbblocks - first_block + nbgroups - 1)/nbgroups, 8);
@@ -1934,51 +2582,59 @@
        gdsz = rndup(nbgroups*sizeof(groupdescriptor),BLOCKSIZE)/BLOCKSIZE;
        itblsz = nbinodes_per_group * sizeof(inode)/BLOCKSIZE;
        overhead_per_group = 3 /*sb,bbm,ibm*/ + gdsz + itblsz;
-       if((uint32)nbblocks - 1 < overhead_per_group * nbgroups)
-               error_msg_and_die("too much overhead, try fewer inodes or more blocks. Note: options have changed, see --help or the man page.");
-       free_blocks = nbblocks - overhead_per_group*nbgroups - 1 /*boot block*/;
+       free_blocks = nbblocks - overhead_per_group*nbgroups - first_block;
        free_blocks_per_group = nbblocks_per_group - overhead_per_group;
+       if(free_blocks < 0)
+               error_msg_and_die("too much overhead, try fewer inodes or more blocks. Note: options have changed, see --help or the man page.");
 
-       if(!(fs = (filesystem*)calloc(nbblocks, BLOCKSIZE)))
-               error_msg_and_die("not enough memory for filesystem");
+       fs = alloc_fs(swapit, fname, nbblocks, NULL);
+       fs->sb = calloc(1, SUPERBLOCK_SIZE);
+       if (!fs->sb)
+               error_msg_and_die("error allocating header memory");
 
        // create the superblock for an empty filesystem
-       fs->sb.s_inodes_count = nbinodes_per_group * nbgroups;
-       fs->sb.s_blocks_count = nbblocks;
-       fs->sb.s_r_blocks_count = nbresrvd;
-       fs->sb.s_free_blocks_count = free_blocks;
-       fs->sb.s_free_inodes_count = fs->sb.s_inodes_count - EXT2_FIRST_INO + 1;
-       fs->sb.s_first_data_block = first_block;
-       fs->sb.s_log_block_size = BLOCKSIZE >> 11;
-       fs->sb.s_log_frag_size = BLOCKSIZE >> 11;
-       fs->sb.s_blocks_per_group = nbblocks_per_group;
-       fs->sb.s_frags_per_group = nbblocks_per_group;
-       fs->sb.s_inodes_per_group = nbinodes_per_group;
-       fs->sb.s_wtime = fs_timestamp;
-       fs->sb.s_magic = EXT2_MAGIC_NUMBER;
-       fs->sb.s_lastcheck = fs_timestamp;
+       fs->sb->s_inodes_count = nbinodes_per_group * nbgroups;
+       fs->sb->s_blocks_count = nbblocks;
+       fs->sb->s_r_blocks_count = nbresrvd;
+       fs->sb->s_free_blocks_count = free_blocks;
+       fs->sb->s_free_inodes_count = fs->sb->s_inodes_count - EXT2_FIRST_INO + 1;
+       fs->sb->s_first_data_block = first_block;
+       fs->sb->s_log_block_size = BLOCKSIZE >> 11;
+       fs->sb->s_log_frag_size = BLOCKSIZE >> 11;
+       fs->sb->s_blocks_per_group = nbblocks_per_group;
+       fs->sb->s_frags_per_group = nbblocks_per_group;
+       fs->sb->s_inodes_per_group = nbinodes_per_group;
+       fs->sb->s_wtime = fs_timestamp;
+       fs->sb->s_magic = EXT2_MAGIC_NUMBER;
+       fs->sb->s_lastcheck = fs_timestamp;
+       fs->sb->s_creator_os = creator_os;
+
+       set_file_size(fs);
 
        // set up groupdescriptors
-       for(i=0, bbmpos=gdsz+2, ibmpos=bbmpos+1, itblpos=ibmpos+1;
+       for(i=0, bbmpos=first_block+1+gdsz, ibmpos=bbmpos+1, itblpos=ibmpos+1;
                i<nbgroups;
                i++, bbmpos+=nbblocks_per_group, ibmpos+=nbblocks_per_group, itblpos+=nbblocks_per_group)
        {
+               gd = get_gd(fs, i, &gi);
+
                if(free_blocks > free_blocks_per_group) {
-                       fs->gd[i].bg_free_blocks_count = free_blocks_per_group;
+                       gd->bg_free_blocks_count = free_blocks_per_group;
                        free_blocks -= free_blocks_per_group;
                } else {
-                       fs->gd[i].bg_free_blocks_count = free_blocks;
+                       gd->bg_free_blocks_count = free_blocks;
                        free_blocks = 0; // this is the last block group
                }
                if(i)
-                       fs->gd[i].bg_free_inodes_count = nbinodes_per_group;
+                       gd->bg_free_inodes_count = nbinodes_per_group;
                else
-                       fs->gd[i].bg_free_inodes_count = nbinodes_per_group -
+                       gd->bg_free_inodes_count = nbinodes_per_group -
                                                        EXT2_FIRST_INO + 2;
-               fs->gd[i].bg_used_dirs_count = 0;
-               fs->gd[i].bg_block_bitmap = bbmpos;
-               fs->gd[i].bg_inode_bitmap = ibmpos;
-               fs->gd[i].bg_inode_table = itblpos;
+               gd->bg_used_dirs_count = 0;
+               gd->bg_block_bitmap = bbmpos;
+               gd->bg_inode_bitmap = ibmpos;
+               gd->bg_inode_table = itblpos;
+               put_gd(gi);
        }
 
        /* Mark non-filesystem blocks and inodes as allocated */
@@ -1984,110 +2640,143 @@
        /* Mark non-filesystem blocks and inodes as allocated */
        /* Mark system blocks and inodes as allocated         */
        for(i = 0; i<nbgroups;i++) {
-
                /* Block bitmap */
-               bbm = get_blk(fs,fs->gd[i].bg_block_bitmap);    
+               gd = get_gd(fs, i, &gi);
+               bbm = GRP_GET_GROUP_BBM(fs, gd, &bi);
                //non-filesystem blocks
-               for(j = fs->gd[i].bg_free_blocks_count
+               for(j = gd->bg_free_blocks_count
                        + overhead_per_group + 1; j <= BLOCKSIZE * 8; j++)
                        allocate(bbm, j); 
                //system blocks
                for(j = 1; j <= overhead_per_group; j++)
                        allocate(bbm, j); 
-               
+               GRP_PUT_GROUP_BBM(bi);
+
                /* Inode bitmap */
-               ibm = get_blk(fs,fs->gd[i].bg_inode_bitmap);    
+               ibm = GRP_GET_GROUP_IBM(fs, gd, &bi);
                //non-filesystem inodes
-               for(j = fs->sb.s_inodes_per_group+1; j <= BLOCKSIZE * 8; j++)
+               for(j = fs->sb->s_inodes_per_group+1; j <= BLOCKSIZE * 8; j++)
                        allocate(ibm, j);
 
                //system inodes
                if(i == 0)
                        for(j = 1; j < EXT2_FIRST_INO; j++)
                                allocate(ibm, j);
+               GRP_PUT_GROUP_IBM(bi);
+               put_gd(gi);
        }
 
        // make root inode and directory
        /* We have groups now. Add the root filesystem in group 0 */
        /* Also increment the directory count for group 0 */
-       fs->gd[0].bg_free_inodes_count--;
-       fs->gd[0].bg_used_dirs_count = 1;
-       itab0 = (inode *)get_blk(fs,fs->gd[0].bg_inode_table);
-       itab0[EXT2_ROOT_INO-1].i_mode = FM_IFDIR | FM_IRWXU | FM_IRGRP | FM_IROTH | FM_IXGRP | FM_IXOTH; 
-       itab0[EXT2_ROOT_INO-1].i_ctime = fs_timestamp;
-       itab0[EXT2_ROOT_INO-1].i_mtime = fs_timestamp;
-       itab0[EXT2_ROOT_INO-1].i_atime = fs_timestamp;
-       itab0[EXT2_ROOT_INO-1].i_size = BLOCKSIZE;
-       itab0[EXT2_ROOT_INO-1].i_links_count = 2;
-
-       if(!(b = get_workblk()))
-               error_msg_and_die("get_workblk() failed.");
-       d = (directory*)b;
-       d->d_inode = EXT2_ROOT_INO;
-       d->d_rec_len = sizeof(directory)+4;
-       d->d_name_len = 1;
-       strcpy(d->d_name, ".");
-       d = (directory*)(b + d->d_rec_len);
-       d->d_inode = EXT2_ROOT_INO;
-       d->d_rec_len = BLOCKSIZE - (sizeof(directory)+4);
-       d->d_name_len = 2;
-       strcpy(d->d_name, "..");
-       extend_blk(fs, EXT2_ROOT_INO, b, 1);
+       gd = get_gd(fs, 0, &gi);
+       gd->bg_free_inodes_count--;
+       gd->bg_used_dirs_count = 1;
+       put_gd(gi);
+       itab0 = get_nod(fs, EXT2_ROOT_INO, &ni);
+       itab0->i_mode = FM_IFDIR | FM_IRWXU | FM_IRGRP | FM_IROTH | FM_IXGRP | FM_IXOTH;
+       itab0->i_ctime = fs_timestamp;
+       itab0->i_mtime = fs_timestamp;
+       itab0->i_atime = fs_timestamp;
+       itab0->i_size = BLOCKSIZE;
+       itab0->i_links_count = 2;
+       put_nod(ni);
+
+       new_dir(fs, EXT2_ROOT_INO, ".", 1, &dw);
+       shrink_dir(&dw, EXT2_ROOT_INO, "..", 2);
+       next_dir(&dw); // Force the data into the buffer
+       inode_pos_init(fs, &ipos, EXT2_ROOT_INO, INODE_POS_EXTEND, NULL);
+       extend_inode_blk(fs, &ipos, dir_data(&dw), 1);
+       inode_pos_finish(fs, &ipos);
+       put_dir(&dw);
 
-       // make lost+found directory and reserve blocks
-       if(fs->sb.s_r_blocks_count)
+       // make lost+found directory
+       if(fs->sb->s_r_blocks_count)
        {
-               nod = mkdir_fs(fs, EXT2_ROOT_INO, "lost+found", FM_IRWXU, 0, 0, fs_timestamp, fs_timestamp);
+               inode *node;
+               uint8 *b;
+
+               nod = mkdir_fs(fs, EXT2_ROOT_INO, "lost+found", FM_IRWXU,
+                              0, 0, fs_timestamp, fs_timestamp);
+               b = get_workblk();
                memset(b, 0, BLOCKSIZE);
                ((directory*)b)->d_rec_len = BLOCKSIZE;
-               /* We run into problems with e2fsck if directory lost+found grows
-                * bigger than this. Need to find out why this happens - sundar
-                */
-               if (fs->sb.s_r_blocks_count > fs->sb.s_blocks_count * MAX_RESERVED_BLOCKS ) 
-                       fs->sb.s_r_blocks_count = fs->sb.s_blocks_count * MAX_RESERVED_BLOCKS;
-               for(i = 1; i < fs->sb.s_r_blocks_count; i++)
-                       extend_blk(fs, nod, b, 1);
-               get_nod(fs, nod)->i_size = fs->sb.s_r_blocks_count * BLOCKSIZE;
+               inode_pos_init(fs, &ipos, nod, INODE_POS_EXTEND, NULL);
+               // It is always 16 blocks to start out with
+               for(i = 1; i < 16; i++)
+                       extend_inode_blk(fs, &ipos, b, 1);
+               inode_pos_finish(fs, &ipos);
+               free_workblk(b);
+               node = get_nod(fs, nod, &ni);
+               node->i_size = 16 * BLOCKSIZE;
+               put_nod(ni);
        }
-       free_workblk(b);
 
        // administrative info
-       fs->sb.s_state = 1;
-       fs->sb.s_max_mnt_count = 20;
+       fs->sb->s_state = 1;
+       fs->sb->s_max_mnt_count = 20;
 
        // options for me
-       if(holes)
-               fs->sb.s_reserved[200] |= OP_HOLES;
+       fs->holes = holes;
        
        return fs;
 }
 
 // loads a filesystem from disk
 static filesystem *
-load_fs(FILE * fh, int swapit)
+load_fs(FILE *fh, int swapit, char *fname)
 {
-       size_t fssize;
+       off_t fssize;
        filesystem *fs;
-       if((fseek(fh, 0, SEEK_END) < 0) || ((ssize_t)(fssize = ftell(fh)) == -1))
+
+       if((fseek(fh, 0, SEEK_END) < 0) || ((fssize = ftello(fh)) == -1))
                perror_msg_and_die("input filesystem image");
        rewind(fh);
-       fssize = (fssize + BLOCKSIZE - 1) / BLOCKSIZE;
+       if ((fssize % BLOCKSIZE) != 0)
+               error_msg_and_die("Input file not a multiple of block size");
+       fssize /= BLOCKSIZE;
        if(fssize < 16) // totally arbitrary
                error_msg_and_die("too small filesystem");
-       if(!(fs = (filesystem*)calloc(fssize, BLOCKSIZE)))
-               error_msg_and_die("not enough memory for filesystem");
-       if(fread(fs, BLOCKSIZE, fssize, fh) != fssize)
-               perror_msg_and_die("input filesystem image");
+       fs = alloc_fs(swapit, fname, fssize, fh);
+
+       /* Read and check the superblock, then read the superblock
+        * and all the group descriptors */
+       fs->sb = malloc(SUPERBLOCK_SIZE);
+       if (!fs->sb)
+               error_msg_and_die("error allocating header memory");
+       if (fseek(fs->f, SUPERBLOCK_OFFSET, SEEK_SET))
+               perror_msg_and_die("fseek");
+       if (fread(fs->sb, SUPERBLOCK_SIZE, 1, fs->f) != 1)
+               perror_msg_and_die("fread filesystem image superblock");
        if(swapit)
-               swap_badfs(fs);
-       if(fs->sb.s_rev_level || (fs->sb.s_magic != EXT2_MAGIC_NUMBER))
+               swap_sb(fs->sb);
+
+       if((fs->sb->s_rev_level > 1) || (fs->sb->s_magic != EXT2_MAGIC_NUMBER))
                error_msg_and_die("not a suitable ext2 filesystem");
+       if (fs->sb->s_rev_level > 0) {
+               if (fs->sb->s_first_ino != EXT2_GOOD_OLD_FIRST_INO)
+                       error_msg_and_die("First inode incompatible");
+               if (fs->sb->s_inode_size != EXT2_GOOD_OLD_INODE_SIZE)
+                       error_msg_and_die("inode size incompatible");
+               if (fs->sb->s_feature_compat)
+                       error_msg_and_die("Unsupported compat features");
+               if (fs->sb->s_feature_incompat)
+                       error_msg_and_die("Unsupported incompat features");
+               if (fs->sb->s_feature_ro_compat
+                   & ~EXT2_FEATURE_RO_COMPAT_LARGE_FILE)
+                       error_msg_and_die("Unsupported ro compat features");
+       }
+
+       set_file_size(fs);
        return fs;
 }
 
 static void
 free_fs(filesystem *fs)
 {
+       free(fs->hdlinks.hdl);
+       fclose(fs->f);
+       free(fs->sb);
        free(fs);
 }
 
@@ -2123,16 +2812,23 @@
 {
        blockwalker bw;
        uint32 bk;
-       int32 fsize = get_nod(fs, nod)->i_size;
+       nod_info *ni;
+       inode *node = get_nod(fs, nod, &ni);
+       int32 fsize = node->i_size;
+       blk_info *bi;
+
        init_bw(&bw);
        while((bk = walk_bw(fs, nod, &bw, 0, 0)) != WALK_END)
        {
                if(fsize <= 0)
                        error_msg_and_die("wrong size while saving inode %d", nod);
-               if(fwrite(get_blk(fs, bk), (fsize > BLOCKSIZE) ? BLOCKSIZE : fsize, 1, f) != 1)
+               if(fwrite(get_blk(fs, bk, &bi),
+                         (fsize > BLOCKSIZE) ? BLOCKSIZE : fsize, 1, f) != 1)
                        error_msg_and_die("error while saving inode %d", nod);
+               put_blk(bi);
                fsize -= BLOCKSIZE;
        }
+       put_nod(ni);
 }
 
 
@@ -2141,8 +2837,11 @@
 print_dev(filesystem *fs, uint32 nod)
 {
        int minor, major;
-       minor = ((uint8*)get_nod(fs, nod)->i_block)[0];
-       major = ((uint8*)get_nod(fs, nod)->i_block)[1];
+       nod_info *ni;
+       inode *node = get_nod(fs, nod, &ni);
+       minor = ((uint8*)node->i_block)[0];
+       major = ((uint8*)node->i_block)[1];
+       put_nod(ni);
        printf("major: %d, minor: %d\n", major, minor);
 }
 
@@ -2157,17 +2856,15 @@
        while((bk = walk_bw(fs, nod, &bw, 0, 0)) != WALK_END)
        {
                directory *d;
-               uint8 *b;
-               b = get_blk(fs, bk);
-               for(d = (directory*)b; (int8*)d + sizeof(*d) < (int8*)b + BLOCKSIZE; d = (directory*)((int8*)d + d->d_rec_len))
+               dirwalker dw;
+               for (d = get_dir(fs, bk, &dw); d; d = next_dir(&dw))
                        if(d->d_inode)
                        {
-                               int i;
                                printf("entry '");
-                               for(i = 0; i < d->d_name_len; i++)
-                                       putchar(d->d_name[i]);
+                               fwrite(dir_name(&dw), 1, d->d_name_len, stdout);
                                printf("' (inode %d): rec_len: %d (name_len: %d)\n", d->d_inode, d->d_rec_len, d->d_name_len);
                        }
+               put_dir(&dw);
        }
 }
 
@@ -2175,14 +2872,18 @@
 static void
 print_link(filesystem *fs, uint32 nod)
 {
-       if(!get_nod(fs, nod)->i_blocks)
-               printf("links to '%s'\n", (char*)get_nod(fs, nod)->i_block);
+       nod_info *ni;
+       inode *node = get_nod(fs, nod, &ni);
+
+       if(!node->i_blocks)
+               printf("links to '%s'\n", (char*)node->i_block);
        else
        {
                printf("links to '");
                write_blocks(fs, nod, stdout);
                printf("'\n");
        }
+       put_nod(ni);
 }
 
 // make a ls-like printout of permissions
@@ -2251,8 +2952,13 @@
 {
        char *s;
        char perms[11];
-       if(!get_nod(fs, nod)->i_mode)
-               return;
+       nod_info *ni;
+       inode *node = get_nod(fs, nod, &ni);
+       blk_info *bi;
+       gd_info *gi;
+
+       if(!node->i_mode)
+               goto out;
        switch(nod)
        {
                case EXT2_BAD_INO:
@@ -2274,15 +2980,18 @@
                default:
                        s = (nod >= EXT2_FIRST_INO) ? "normal" : "unknown reserved"; 
        }
-       printf("inode %d (%s, %d links): ", nod, s, get_nod(fs, nod)->i_links_count);
-       if(!allocated(GRP_GET_INODE_BITMAP(fs,nod), GRP_IBM_OFFSET(fs,nod)))
+       printf("inode %d (%s, %d links): ", nod, s, node->i_links_count);
+       if(!allocated(GRP_GET_INODE_BITMAP(fs,nod,&bi,&gi), GRP_IBM_OFFSET(fs,nod)))
        {
+               GRP_PUT_INODE_BITMAP(bi,gi);
                printf("unallocated\n");
-               return;
+               goto out;
        }
-       make_perms(get_nod(fs, nod)->i_mode, perms);
-       printf("%s,  size: %d byte%s (%d block%s)\n", perms, plural(get_nod(fs, nod)->i_size), plural(get_nod(fs, nod)->i_blocks / INOBLK));
-       switch(get_nod(fs, nod)->i_mode & FM_IFMT)
+       GRP_PUT_INODE_BITMAP(bi,gi);
+       make_perms(node->i_mode, perms);
+       printf("%s,  size: %d byte%s (%d block%s)\n", perms,
+              plural(node->i_size), plural(node->i_blocks / INOBLK));
+       switch(node->i_mode & FM_IFMT)
        {
                case FM_IFSOCK:
                        list_blocks(fs, nod);
@@ -2310,6 +3019,8 @@
                        list_blocks(fs, nod);
        }
        printf("Done with inode %d\n",nod);
+out:
+       put_nod(ni);
 }
 
 // describes various fields in a filesystem
@@ -2317,49 +3028,65 @@
 print_fs(filesystem *fs)
 {
        uint32 i;
+       blk_info *bi;
+       groupdescriptor *gd;
+       gd_info *gi;
        uint8 *ibm;
 
        printf("%d blocks (%d free, %d reserved), first data block: %d\n",
-              fs->sb.s_blocks_count, fs->sb.s_free_blocks_count,
-              fs->sb.s_r_blocks_count, fs->sb.s_first_data_block);
-       printf("%d inodes (%d free)\n", fs->sb.s_inodes_count,
-              fs->sb.s_free_inodes_count);
+              fs->sb->s_blocks_count, fs->sb->s_free_blocks_count,
+              fs->sb->s_r_blocks_count, fs->sb->s_first_data_block);
+       printf("%d inodes (%d free)\n", fs->sb->s_inodes_count,
+              fs->sb->s_free_inodes_count);
        printf("block size = %d, frag size = %d\n",
-              fs->sb.s_log_block_size ? (fs->sb.s_log_block_size << 11) : 1024,
-              fs->sb.s_log_frag_size ? (fs->sb.s_log_frag_size << 11) : 1024);
+              fs->sb->s_log_block_size ? (fs->sb->s_log_block_size << 11) : 1024,
+              fs->sb->s_log_frag_size ? (fs->sb->s_log_frag_size << 11) : 1024);
        printf("number of groups: %d\n",GRP_NBGROUPS(fs));
        printf("%d blocks per group,%d frags per group,%d inodes per group\n",
-            fs->sb.s_blocks_per_group, fs->sb.s_frags_per_group,
-            fs->sb.s_inodes_per_group);
+            fs->sb->s_blocks_per_group, fs->sb->s_frags_per_group,
+            fs->sb->s_inodes_per_group);
        printf("Size of inode table: %d blocks\n",
-               (int)(fs->sb.s_inodes_per_group * sizeof(inode) / BLOCKSIZE));
+               (int)(fs->sb->s_inodes_per_group * sizeof(inode) / BLOCKSIZE));
        for (i = 0; i < GRP_NBGROUPS(fs); i++) {
                printf("Group No: %d\n", i+1);
+               gd = get_gd(fs, i, &gi);
                printf("block bitmap: block %d,inode bitmap: block %d, inode table: block %d\n",
-                    fs->gd[i].bg_block_bitmap, fs->gd[i].bg_inode_bitmap,
-                    fs->gd[i].bg_inode_table);
+                    gd->bg_block_bitmap,
+                    gd->bg_inode_bitmap,
+                    gd->bg_inode_table);
                printf("block bitmap allocation:\n");
-               print_bm(GRP_GET_GROUP_BBM(fs, i),fs->sb.s_blocks_per_group);
+               print_bm(GRP_GET_GROUP_BBM(fs, gd, &bi),fs->sb->s_blocks_per_group);
+               GRP_PUT_GROUP_BBM(bi);
                printf("inode bitmap allocation:\n");
-               ibm = GRP_GET_GROUP_IBM(fs, i);
-               print_bm(ibm, fs->sb.s_inodes_per_group);
-               for (i = 1; i <= fs->sb.s_inodes_per_group; i++)
+               ibm = GRP_GET_GROUP_IBM(fs, gd, &bi);
+               print_bm(ibm, fs->sb->s_inodes_per_group);
+               for (i = 1; i <= fs->sb->s_inodes_per_group; i++)
                        if (allocated(ibm, i))
                                print_inode(fs, i);
+               GRP_PUT_GROUP_IBM(bi);
+               put_gd(gi);
        }
 }
 
 static void
-dump_fs(filesystem *fs, FILE * fh, int swapit)
+finish_fs(filesystem *fs)
 {
-       uint32 nbblocks = fs->sb.s_blocks_count;
-       fs->sb.s_reserved[200] = 0;
-       if(swapit)
-               swap_goodfs(fs);
-       if(fwrite(fs, BLOCKSIZE, nbblocks, fh) < nbblocks)
-               perror_msg_and_die("output filesystem image");
-       if(swapit)
-               swap_badfs(fs);
+       if (cache_flush(&fs->inodes))
+               error_msg_and_die("entry mismatch on inode cache flush");
+       if (cache_flush(&fs->blkmaps))
+               error_msg_and_die("entry mismatch on blockmap cache flush");
+       if (cache_flush(&fs->gds))
+               error_msg_and_die("entry mismatch on gd cache flush");
+       if (cache_flush(&fs->blks))
+               error_msg_and_die("entry mismatch on block cache flush");
+       if(fs->swapit)
+               swap_sb(fs->sb);
+       if (fseek(fs->f, SUPERBLOCK_OFFSET, SEEK_SET))
+               perror_msg_and_die("fseek");
+       if(fwrite(fs->sb, SUPERBLOCK_SIZE, 1, fs->f) != 1)
+               perror_msg_and_die("output filesystem superblock");
+       if(fs->swapit)
+               swap_sb(fs->sb);
 }
 
 static void
@@ -2419,10 +3146,12 @@
        "  -x, --starting-image <image>\n"
        "  -d, --root <directory>\n"
        "  -D, --devtable <file>\n"
+       "  -B, --block-size <bytes>\n"
        "  -b, --size-in-blocks <blocks>\n"
        "  -i, --bytes-per-inode <bytes per inode>\n"
        "  -N, --number-of-inodes <number of inodes>\n"
        "  -m, --reserved-percentage <percentage of blocks to reserve>\n"
+       "  -o, --creator-os <os>      'linux' (default), 'hurd', 'freebsd' or number.\n"
        "  -g, --block-map <path>     Generate a block map file for this path.\n"
        "  -e, --fill-value <value>   Fill unallocated blocks with value.\n"
        "  -z, --allow-holes          Allow files with holes.\n"
@@ -2444,15 +3173,34 @@
 extern char* optarg;
 extern int optind, opterr, optopt;
 
+// parse the value for -o <os>
+int
+lookup_creator_os(const char *name)
+{
+        if (isdigit (*name))
+                return atoi(name);
+        else if (strcasecmp(name, "linux") == 0)
+                return EXT2_OS_LINUX;
+        else if (strcasecmp(name, "GNU") == 0 || strcasecmp(name, "hurd") == 0)
+                return EXT2_OS_HURD;
+        else if (strcasecmp(name, "freebsd") == 0)
+                return EXT2_OS_FREEBSD;
+        else if (strcasecmp(name, "lites") == 0)
+                return EXT2_OS_LITES;
+        else
+                return EXT2_OS_LINUX;
+}
+
 int
 main(int argc, char **argv)
 {
-       int nbblocks = -1;
+       long long nbblocks = -1;
        int nbinodes = -1;
        int nbresrvd = -1;
        float bytes_per_inode = -1;
        float reserved_frac = -1;
        int fs_timestamp = -1;
+       int creator_os = CREATOR_OS;
        char * fsout = "-";
        char * fsin = 0;
        char * dopt[MAX_DOPT];
@@ -2466,6 +3214,7 @@
        int squash_perms = 0;
        uint16 endian = 1;
        int bigendian = !*(char*)&endian;
+       char *volumelabel = NULL;
        filesystem *fs;
        int i;
        int c;
@@ -2476,13 +3225,16 @@
          { "starting-image",   required_argument,      NULL, 'x' },
          { "root",             required_argument,      NULL, 'd' },
          { "devtable",         required_argument,      NULL, 'D' },
+         { "block-size",       required_argument,      NULL, 'B' },
          { "size-in-blocks",   required_argument,      NULL, 'b' },
          { "bytes-per-inode",  required_argument,      NULL, 'i' },
          { "number-of-inodes", required_argument,      NULL, 'N' },
+         { "volume-label",     required_argument,      NULL, 'L' },
          { "reserved-percentage", required_argument,   NULL, 'm' },
+         { "creator-os",       required_argument,      NULL, 'o' },
          { "block-map",        required_argument,      NULL, 'g' },
          { "fill-value",       required_argument,      NULL, 'e' },
-         { "allow-holes",      no_argument,            NULL, 'z' },
+         { "allow-holes",      no_argument,            NULL, 'z' },
          { "faketime",         no_argument,            NULL, 'f' },
          { "squash",           no_argument,            NULL, 'q' },
          { "squash-uids",      no_argument,            NULL, 'U' },
@@ -2495,11 +3247,11 @@
 
        app_name = argv[0];
 
-       while((c = getopt_long(argc, argv, "x:d:D:b:i:N:m:g:e:zfqUPhVv", longopts, NULL)) != EOF) {
+       while((c = getopt_long(argc, argv, "x:d:D:B:b:i:N:L:m:o:g:e:zfqUPhVv", longopts, NULL)) != EOF) {
 #else
        app_name = argv[0];
 
-       while((c = getopt(argc, argv,      "x:d:D:b:i:N:m:g:e:zfqUPhVv")) != EOF) {
+       while((c = getopt(argc, argv,      "x:d:D:B:b:i:N:L:m:o:g:e:zfqUPhVv")) != EOF) {
 #endif /* HAVE_GETOPT_LONG */
                switch(c)
                {
@@ -2510,6 +3262,9 @@
                        case 'D':
                                dopt[didx++] = optarg;
                                break;
+                       case 'B':
+                               blocksize = SI_atof(optarg);
+                               break;
                        case 'b':
                                nbblocks = SI_atof(optarg);
                                break;
@@ -2519,9 +3274,15 @@
                        case 'N':
                                nbinodes = SI_atof(optarg);
                                break;
+                       case 'L':
+                               volumelabel = optarg;
+                               break;
                        case 'm':
                                reserved_frac = SI_atof(optarg) / 100;
                                break;
+                       case 'o':
+                               creator_os = lookup_creator_os(optarg);
+                               break;
                        case 'g':
                                gopt[gidx++] = optarg;
                                break;
@@ -2565,21 +3326,21 @@
                error_msg_and_die("Not enough arguments. Try --help or else see the man page.");
        fsout = argv[optind];
 
-       hdlinks.hdl = (struct hdlink_s *)malloc(hdlink_cnt * sizeof(struct hdlink_s));
-       if (!hdlinks.hdl)
-               error_msg_and_die("Not enough memory");
-       hdlinks.count = 0 ;
+       if(blocksize != 1024 && blocksize != 2048 && blocksize != 4096)
+               error_msg_and_die("Valid block sizes: 1024, 2048 or 4096.");
+       if(creator_os < 0)
+               error_msg_and_die("Creator OS unknown.");
 
        if(fsin)
        {
                if(strcmp(fsin, "-"))
                {
                        FILE * fh = xfopen(fsin, "rb");
-                       fs = load_fs(fh, bigendian);
+                       fs = load_fs(fh, bigendian, fsout);
                        fclose(fh);
                }
                else
-                       fs = load_fs(stdin, bigendian);
+                       fs = load_fs(stdin, bigendian, fsout);
        }
        else
        {
@@ -2609,16 +3370,29 @@
                }
                if(fs_timestamp == -1)
                        fs_timestamp = time(NULL);
-               fs = init_fs(nbblocks, nbinodes, nbresrvd, holes, fs_timestamp);
+               fs = init_fs(nbblocks, nbinodes, nbresrvd, holes,
+                            fs_timestamp, creator_os, bigendian, fsout);
        }
+       if (volumelabel != NULL)
+               strncpy((char *)fs->sb->s_volume_name, volumelabel,
+                       sizeof(fs->sb->s_volume_name));
        
        populate_fs(fs, dopt, didx, squash_uids, squash_perms, fs_timestamp, NULL);
 
        if(emptyval) {
                uint32 b;
-               for(b = 1; b < fs->sb.s_blocks_count; b++)
-                       if(!allocated(GRP_GET_BLOCK_BITMAP(fs,b),GRP_BBM_OFFSET(fs,b)))
-                               memset(get_blk(fs, b), emptyval, BLOCKSIZE);
+               for(b = 1; b < fs->sb->s_blocks_count; b++) {
+                       blk_info *bi;
+                       gd_info *gi;
+                       if(!allocated(GRP_GET_BLOCK_BITMAP(fs,b,&bi,&gi),
+                                     GRP_BBM_OFFSET(fs,b))) {
+                               blk_info *bi2;
+                               memset(get_blk(fs, b, &bi2), emptyval,
+                                      BLOCKSIZE);
+                               put_blk(bi2);
+                       }
+                       GRP_PUT_BLOCK_BITMAP(bi,gi);
+               }
        }
        if(verbose)
                print_fs(fs);
@@ -2628,24 +3402,22 @@
                char fname[MAX_FILENAME];
                char *p;
                FILE *fh;
+               nod_info *ni;
                if(!(nod = find_path(fs, EXT2_ROOT_INO, gopt[i])))
                        error_msg_and_die("path %s not found in filesystem", gopt[i]);
                while((p = strchr(gopt[i], '/')))
                        *p = '_';
                SNPRINTF(fname, MAX_FILENAME-1, "%s.blk", gopt[i]);
                fh = xfopen(fname, "wb");
-               fprintf(fh, "%d:", get_nod(fs, nod)->i_size);
+               fprintf(fh, "%d:", get_nod(fs, nod, &ni)->i_size);
+               put_nod(ni);
                flist_blocks(fs, nod, fh);
                fclose(fh);
        }
-       if(strcmp(fsout, "-"))
-       {
-               FILE * fh = xfopen(fsout, "wb");
-               dump_fs(fs, fh, bigendian);
-               fclose(fh);
-       }
-       else
-               dump_fs(fs, stdout, bigendian);
+       finish_fs(fs);
+       if(strcmp(fsout, "-") == 0)
+               copy_file(fs, stdout, fs->f, fs->sb->s_blocks_count);
+
        free_fs(fs);
        return 0;
 }
Index: genext2fs-1.4.1/cache.h
===================================================================
--- /dev/null
+++ genext2fs-1.4.1/cache.h
@@ -0,0 +1,128 @@
+#ifndef __CACHE_H__
+#define __CACHE_H__
+
+#include "list.h"
+
+#define CACHE_LISTS 256
+
+typedef struct
+{
+    list_elem link;
+    list_elem lru_link;
+} cache_link;
+
+typedef struct
+{
+    /* LRU list holds unused items */
+    unsigned int lru_entries;
+    list_elem lru_list;
+    unsigned int max_free_entries;
+
+    unsigned int entries;
+    list_elem lists[CACHE_LISTS];
+    unsigned int (*elem_val)(cache_link *elem);
+    void (*freed)(cache_link *elem);
+} listcache;
+
+static inline void
+cache_add(listcache *c, cache_link *elem)
+{
+    unsigned int hash = c->elem_val(elem) % CACHE_LISTS;
+    int delcount = c->lru_entries - c->max_free_entries;
+
+    if (delcount > 0) {
+        /* Delete some unused items. */
+        list_elem *lru, *next;
+        cache_link *l;
+        list_for_each_elem_safe(&c->lru_list, lru, next) {
+            l = container_of(lru, cache_link, lru_link);
+            list_del(lru);
+            list_del(&l->link);
+            c->entries--;
+            c->lru_entries--;
+            c->freed(l);
+            delcount--;
+            if (delcount <= 0)
+                break;
+        }
+    }
+
+    c->entries++;
+    list_item_init(&elem->lru_link); /* Mark it not in the LRU list */
+    list_add_after(&c->lists[hash], &elem->link);
+}
+
+static inline void
+cache_item_set_unused(listcache *c, cache_link *elem)
+{
+    list_add_before(&c->lru_list, &elem->lru_link);
+    c->lru_entries++;
+}
+
+static inline cache_link *
+cache_find(listcache *c, unsigned int val)
+{
+    unsigned int hash = val % CACHE_LISTS;
+    list_elem *elem;
+
+    list_for_each_elem(&c->lists[hash], elem) {
+        cache_link *l = container_of(elem, cache_link, link);
+        if (c->elem_val(l) == val) {
+            if (!list_empty(&l->lru_link)) {
+                /* It's in the unused list, remove it. */
+                list_del(&l->lru_link);
+                list_item_init(&l->lru_link);
+                c->lru_entries--;
+            }
+            return l;
+        }
+    }
+    return NULL;
+}
+
+static inline int
+cache_flush(listcache *c)
+{
+    list_elem *elem, *next;
+    cache_link *l;
+    int i;
+
+    list_for_each_elem_safe(&c->lru_list, elem, next) {
+        l = container_of(elem, cache_link, lru_link);
+        list_del(elem);
+        list_del(&l->link);
+        c->entries--;
+        c->lru_entries--;
+        c->freed(l);
+    }
+
+    for (i = 0; i < CACHE_LISTS; i++) {
+        list_for_each_elem_safe(&c->lists[i], elem, next) {
+            l = container_of(elem, cache_link, link);
+            list_del(&l->link);
+            c->entries--;
+            c->freed(l);
+        }
+    }
+
+    return c->entries || c->lru_entries;
+}
+
+static inline void
+cache_init(listcache *c, unsigned int max_free_entries,
+       unsigned int (*elem_val)(cache_link *elem),
+       void (*freed)(cache_link *elem))
+{
+    int i;
+
+    c->entries = 0;
+    c->lru_entries = 0;
+    c->max_free_entries = max_free_entries;
+    list_init(&c->lru_list);
+    for (i = 0; i < CACHE_LISTS; i++)
+        list_init(&c->lists[i]);
+    c->elem_val = elem_val;
+    c->freed = freed;
+}
+
+#endif /* __CACHE_H__ */
Index: genext2fs-1.4.1/list.h
===================================================================
--- /dev/null
+++ genext2fs-1.4.1/list.h
@@ -0,0 +1,78 @@
+#ifndef __LIST_H__
+#define __LIST_H__
+
+#if STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# if HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+# if HAVE_STDDEF_H
+#  include <stddef.h>
+# endif
+#endif
+
+#ifndef offsetof
+#define offsetof(st, m) \
+     ((size_t) ( (char *)&((st *)(0))->m - (char *)0 ))
+#endif
+
+#define container_of(ptr, type, member) ({ \
+                const typeof( ((type *)0)->member ) *__mptr = (ptr); \
+                (type *)( (char *)__mptr - offsetof(type,member) );})
+
+typedef struct list_elem
+{
+    struct list_elem *next;
+    struct list_elem *prev;
+} list_elem;
+
+static inline void list_init(list_elem *list)
+{
+    list->next = list;
+    list->prev = list;
+}
+
+static inline void list_add_after(list_elem *pos, list_elem *elem)
+{
+    elem->next = pos->next;
+    elem->prev = pos;
+    pos->next->prev = elem;
+    pos->next = elem;
+}
+
+static inline void list_add_before(list_elem *pos, list_elem *elem)
+{
+    elem->prev = pos->prev;
+    elem->next = pos;
+    pos->prev->next = elem;
+    pos->prev = elem;
+}
+
+static inline void list_del(list_elem *elem)
+{
+    elem->next->prev = elem->prev;
+    elem->prev->next = elem->next;
+}
+
+static inline void list_item_init(list_elem *elem)
+{
+    elem->next = elem;
+    elem->prev = elem;
+}
+
+static inline int list_empty(list_elem *elem)
+{
+    return elem->next == elem;
+}
+
+#define list_for_each_elem(list, curr)            \
+    for ((curr) = (list)->next; (curr) != (list); (curr) = (curr)->next)
+
+#define list_for_each_elem_safe(list, curr, next)    \
+    for ((curr) = (list)->next, (next) = (curr)->next;    \
+         (curr) != (list);                    \
+         (curr) = (next), (next) = (curr)->next)
+
+#endif /* __LIST_H__ */