[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
  ", 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)
  ", 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'
  ", (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'
  ", (char*)node->i_block);
   	else
   	{
   		printf("links to '");
   		write_blocks(fs, nod, stdout);
   		printf("'
  ");
   	}
  +	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
  ");
  -		return;
  +		goto out;
   	}
  -	make_perms(get_nod(fs, nod)->i_mode, perms);
  -	printf("%s,  size: %d byte%s (%d block%s)
  ", 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)
  ", 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
  ",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
  ",
  -	       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)
  ", 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)
  ", fs->sb->s_inodes_count,
  +	       fs->sb->s_free_inodes_count);
   	printf("block size = %d, frag size = %d
  ",
  -	       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
  ",GRP_NBGROUPS(fs));
   	printf("%d blocks per group,%d frags per group,%d inodes per group
  ",
  -	     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
  ",
  -		(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
  ", i+1);
  +		gd = get_gd(fs, i, &gi);
   		printf("block bitmap: block %d,inode bitmap: block %d, inode table: block %d
  ",
  -		     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:
  ");
  -		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:
  ");
  -		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>
  "
   	"  -d, --root <directory>
  "
   	"  -D, --devtable <file>
  "
  +	"  -B, --block-size <bytes>
  "
   	"  -b, --size-in-blocks <blocks>
  "
   	"  -i, --bytes-per-inode <bytes per inode>
  "
   	"  -N, --number-of-inodes <number of inodes>
  "
   	"  -m, --reserved-percentage <percentage of blocks to reserve>
  "
  +	"  -o, --creator-os <os>      'linux' (default), 'hurd', 'freebsd' or number.
  "
   	"  -g, --block-map <path>     Generate a block map file for this path.
  "
   	"  -e, --fill-value <value>   Fill unallocated blocks with value.
  "
   	"  -z, --allow-holes          Allow files with holes.
  "
  @@ -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__ */