[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 --- 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 #include @@ -107,10 +113,8 @@ #if HAVE_DIRENT_H # include -# define NAMLEN(dirent) strlen((dirent)->d_name) #else # define dirent direct -# define NAMLEN(dirent) (dirent)->d_namlen # if HAVE_SYS_NDIR_H # include # endif @@ -144,6 +148,8 @@ # include #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; ix[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;grpgd[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; grpgd[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; grpgd[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 ( 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 ( 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;igd[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;igd[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 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; igd[i].bg_block_bitmap); + gd = get_gd(fs, i, &gi); + bbm = GRP_GET_GROUP_BBM(fs, gd, &bi); //non-filesystem blocks - for(j = fs->gd[i].bg_free_blocks_count + for(j = gd->bg_free_blocks_count + overhead_per_group + 1; j <= BLOCKSIZE * 8; j++) allocate(bbm, j); //system blocks for(j = 1; j <= overhead_per_group; j++) allocate(bbm, j); - + GRP_PUT_GROUP_BBM(bi); + /* Inode bitmap */ - ibm = get_blk(fs,fs->gd[i].bg_inode_bitmap); + ibm = GRP_GET_GROUP_IBM(fs, gd, &bi); //non-filesystem inodes - for(j = fs->sb.s_inodes_per_group+1; j <= BLOCKSIZE * 8; j++) + for(j = fs->sb->s_inodes_per_group+1; j <= BLOCKSIZE * 8; j++) allocate(ibm, j); //system inodes if(i == 0) for(j = 1; j < EXT2_FIRST_INO; j++) allocate(ibm, j); + GRP_PUT_GROUP_IBM(bi); + put_gd(gi); } // make root inode and directory /* We have groups now. Add the root filesystem in group 0 */ /* Also increment the directory count for group 0 */ - fs->gd[0].bg_free_inodes_count--; - fs->gd[0].bg_used_dirs_count = 1; - itab0 = (inode *)get_blk(fs,fs->gd[0].bg_inode_table); - itab0[EXT2_ROOT_INO-1].i_mode = FM_IFDIR | FM_IRWXU | FM_IRGRP | FM_IROTH | FM_IXGRP | FM_IXOTH; - itab0[EXT2_ROOT_INO-1].i_ctime = fs_timestamp; - itab0[EXT2_ROOT_INO-1].i_mtime = fs_timestamp; - itab0[EXT2_ROOT_INO-1].i_atime = fs_timestamp; - itab0[EXT2_ROOT_INO-1].i_size = BLOCKSIZE; - itab0[EXT2_ROOT_INO-1].i_links_count = 2; - - if(!(b = get_workblk())) - error_msg_and_die("get_workblk() failed."); - d = (directory*)b; - d->d_inode = EXT2_ROOT_INO; - d->d_rec_len = sizeof(directory)+4; - d->d_name_len = 1; - strcpy(d->d_name, "."); - d = (directory*)(b + d->d_rec_len); - d->d_inode = EXT2_ROOT_INO; - d->d_rec_len = BLOCKSIZE - (sizeof(directory)+4); - d->d_name_len = 2; - strcpy(d->d_name, ".."); - extend_blk(fs, EXT2_ROOT_INO, b, 1); + gd = get_gd(fs, 0, &gi); + gd->bg_free_inodes_count--; + gd->bg_used_dirs_count = 1; + put_gd(gi); + itab0 = get_nod(fs, EXT2_ROOT_INO, &ni); + itab0->i_mode = FM_IFDIR | FM_IRWXU | FM_IRGRP | FM_IROTH | FM_IXGRP | FM_IXOTH; + itab0->i_ctime = fs_timestamp; + itab0->i_mtime = fs_timestamp; + itab0->i_atime = fs_timestamp; + itab0->i_size = BLOCKSIZE; + itab0->i_links_count = 2; + put_nod(ni); + + new_dir(fs, EXT2_ROOT_INO, ".", 1, &dw); + shrink_dir(&dw, EXT2_ROOT_INO, "..", 2); + next_dir(&dw); // Force the data into the buffer + inode_pos_init(fs, &ipos, EXT2_ROOT_INO, INODE_POS_EXTEND, NULL); + extend_inode_blk(fs, &ipos, dir_data(&dw), 1); + inode_pos_finish(fs, &ipos); + put_dir(&dw); - // make lost+found directory and reserve blocks - if(fs->sb.s_r_blocks_count) + // make lost+found directory + if(fs->sb->s_r_blocks_count) { - nod = mkdir_fs(fs, EXT2_ROOT_INO, "lost+found", FM_IRWXU, 0, 0, fs_timestamp, fs_timestamp); + inode *node; + uint8 *b; + + nod = mkdir_fs(fs, EXT2_ROOT_INO, "lost+found", FM_IRWXU, + 0, 0, fs_timestamp, fs_timestamp); + b = get_workblk(); memset(b, 0, BLOCKSIZE); ((directory*)b)->d_rec_len = BLOCKSIZE; - /* We run into problems with e2fsck if directory lost+found grows - * bigger than this. Need to find out why this happens - sundar - */ - if (fs->sb.s_r_blocks_count > fs->sb.s_blocks_count * MAX_RESERVED_BLOCKS ) - fs->sb.s_r_blocks_count = fs->sb.s_blocks_count * MAX_RESERVED_BLOCKS; - for(i = 1; i < fs->sb.s_r_blocks_count; i++) - extend_blk(fs, nod, b, 1); - get_nod(fs, nod)->i_size = fs->sb.s_r_blocks_count * BLOCKSIZE; + inode_pos_init(fs, &ipos, nod, INODE_POS_EXTEND, NULL); + // It is always 16 blocks to start out with + for(i = 1; i < 16; i++) + extend_inode_blk(fs, &ipos, b, 1); + inode_pos_finish(fs, &ipos); + free_workblk(b); + node = get_nod(fs, nod, &ni); + node->i_size = 16 * BLOCKSIZE; + put_nod(ni); } - free_workblk(b); // administrative info - fs->sb.s_state = 1; - fs->sb.s_max_mnt_count = 20; + fs->sb->s_state = 1; + fs->sb->s_max_mnt_count = 20; // options for me - if(holes) - fs->sb.s_reserved[200] |= OP_HOLES; + fs->holes = holes; return fs; } // loads a filesystem from disk static filesystem * -load_fs(FILE * fh, int swapit) +load_fs(FILE *fh, int swapit, char *fname) { - size_t fssize; + off_t fssize; filesystem *fs; - if((fseek(fh, 0, SEEK_END) < 0) || ((ssize_t)(fssize = ftell(fh)) == -1)) + + if((fseek(fh, 0, SEEK_END) < 0) || ((fssize = ftello(fh)) == -1)) perror_msg_and_die("input filesystem image"); rewind(fh); - fssize = (fssize + BLOCKSIZE - 1) / BLOCKSIZE; + if ((fssize % BLOCKSIZE) != 0) + error_msg_and_die("Input file not a multiple of block size"); + fssize /= BLOCKSIZE; if(fssize < 16) // totally arbitrary error_msg_and_die("too small filesystem"); - if(!(fs = (filesystem*)calloc(fssize, BLOCKSIZE))) - error_msg_and_die("not enough memory for filesystem"); - if(fread(fs, BLOCKSIZE, fssize, fh) != fssize) - perror_msg_and_die("input filesystem image"); + fs = alloc_fs(swapit, fname, fssize, fh); + + /* Read and check the superblock, then read the superblock + * and all the group descriptors */ + fs->sb = malloc(SUPERBLOCK_SIZE); + if (!fs->sb) + error_msg_and_die("error allocating header memory"); + if (fseek(fs->f, SUPERBLOCK_OFFSET, SEEK_SET)) + perror_msg_and_die("fseek"); + if (fread(fs->sb, SUPERBLOCK_SIZE, 1, fs->f) != 1) + perror_msg_and_die("fread filesystem image superblock"); if(swapit) - swap_badfs(fs); - if(fs->sb.s_rev_level || (fs->sb.s_magic != EXT2_MAGIC_NUMBER)) + swap_sb(fs->sb); + + if((fs->sb->s_rev_level > 1) || (fs->sb->s_magic != EXT2_MAGIC_NUMBER)) error_msg_and_die("not a suitable ext2 filesystem"); + if (fs->sb->s_rev_level > 0) { + if (fs->sb->s_first_ino != EXT2_GOOD_OLD_FIRST_INO) + error_msg_and_die("First inode incompatible"); + if (fs->sb->s_inode_size != EXT2_GOOD_OLD_INODE_SIZE) + error_msg_and_die("inode size incompatible"); + if (fs->sb->s_feature_compat) + error_msg_and_die("Unsupported compat features"); + if (fs->sb->s_feature_incompat) + error_msg_and_die("Unsupported incompat features"); + if (fs->sb->s_feature_ro_compat + & ~EXT2_FEATURE_RO_COMPAT_LARGE_FILE) + error_msg_and_die("Unsupported ro compat features"); + } + + set_file_size(fs); return fs; } static void free_fs(filesystem *fs) { + free(fs->hdlinks.hdl); + fclose(fs->f); + free(fs->sb); free(fs); } @@ -2123,16 +2812,23 @@ { blockwalker bw; uint32 bk; - int32 fsize = get_nod(fs, nod)->i_size; + nod_info *ni; + inode *node = get_nod(fs, nod, &ni); + int32 fsize = node->i_size; + blk_info *bi; + init_bw(&bw); while((bk = walk_bw(fs, nod, &bw, 0, 0)) != WALK_END) { if(fsize <= 0) error_msg_and_die("wrong size while saving inode %d", nod); - if(fwrite(get_blk(fs, bk), (fsize > BLOCKSIZE) ? BLOCKSIZE : fsize, 1, f) != 1) + if(fwrite(get_blk(fs, bk, &bi), + (fsize > BLOCKSIZE) ? BLOCKSIZE : fsize, 1, f) != 1) error_msg_and_die("error while saving inode %d", nod); + put_blk(bi); fsize -= BLOCKSIZE; } + put_nod(ni); } @@ -2141,8 +2837,11 @@ print_dev(filesystem *fs, uint32 nod) { int minor, major; - minor = ((uint8*)get_nod(fs, nod)->i_block)[0]; - major = ((uint8*)get_nod(fs, nod)->i_block)[1]; + nod_info *ni; + inode *node = get_nod(fs, nod, &ni); + minor = ((uint8*)node->i_block)[0]; + major = ((uint8*)node->i_block)[1]; + put_nod(ni); printf("major: %d, minor: %d\n", major, minor); } @@ -2157,17 +2856,15 @@ while((bk = walk_bw(fs, nod, &bw, 0, 0)) != WALK_END) { directory *d; - uint8 *b; - b = get_blk(fs, bk); - for(d = (directory*)b; (int8*)d + sizeof(*d) < (int8*)b + BLOCKSIZE; d = (directory*)((int8*)d + d->d_rec_len)) + dirwalker dw; + for (d = get_dir(fs, bk, &dw); d; d = next_dir(&dw)) if(d->d_inode) { - int i; printf("entry '"); - for(i = 0; i < d->d_name_len; i++) - putchar(d->d_name[i]); + fwrite(dir_name(&dw), 1, d->d_name_len, stdout); printf("' (inode %d): rec_len: %d (name_len: %d)\n", d->d_inode, d->d_rec_len, d->d_name_len); } + put_dir(&dw); } } @@ -2175,14 +2872,18 @@ static void print_link(filesystem *fs, uint32 nod) { - if(!get_nod(fs, nod)->i_blocks) - printf("links to '%s'\n", (char*)get_nod(fs, nod)->i_block); + nod_info *ni; + inode *node = get_nod(fs, nod, &ni); + + if(!node->i_blocks) + printf("links to '%s'\n", (char*)node->i_block); else { printf("links to '"); write_blocks(fs, nod, stdout); printf("'\n"); } + put_nod(ni); } // make a ls-like printout of permissions @@ -2251,8 +2952,13 @@ { char *s; char perms[11]; - if(!get_nod(fs, nod)->i_mode) - return; + nod_info *ni; + inode *node = get_nod(fs, nod, &ni); + blk_info *bi; + gd_info *gi; + + if(!node->i_mode) + goto out; switch(nod) { case EXT2_BAD_INO: @@ -2274,15 +2980,18 @@ default: s = (nod >= EXT2_FIRST_INO) ? "normal" : "unknown reserved"; } - printf("inode %d (%s, %d links): ", nod, s, get_nod(fs, nod)->i_links_count); - if(!allocated(GRP_GET_INODE_BITMAP(fs,nod), GRP_IBM_OFFSET(fs,nod))) + printf("inode %d (%s, %d links): ", nod, s, node->i_links_count); + if(!allocated(GRP_GET_INODE_BITMAP(fs,nod,&bi,&gi), GRP_IBM_OFFSET(fs,nod))) { + GRP_PUT_INODE_BITMAP(bi,gi); printf("unallocated\n"); - return; + goto out; } - make_perms(get_nod(fs, nod)->i_mode, perms); - printf("%s, size: %d byte%s (%d block%s)\n", perms, plural(get_nod(fs, nod)->i_size), plural(get_nod(fs, nod)->i_blocks / INOBLK)); - switch(get_nod(fs, nod)->i_mode & FM_IFMT) + GRP_PUT_INODE_BITMAP(bi,gi); + make_perms(node->i_mode, perms); + printf("%s, size: %d byte%s (%d block%s)\n", perms, + plural(node->i_size), plural(node->i_blocks / INOBLK)); + switch(node->i_mode & FM_IFMT) { case FM_IFSOCK: list_blocks(fs, nod); @@ -2310,6 +3019,8 @@ list_blocks(fs, nod); } printf("Done with inode %d\n",nod); +out: + put_nod(ni); } // describes various fields in a filesystem @@ -2317,49 +3028,65 @@ print_fs(filesystem *fs) { uint32 i; + blk_info *bi; + groupdescriptor *gd; + gd_info *gi; uint8 *ibm; printf("%d blocks (%d free, %d reserved), first data block: %d\n", - fs->sb.s_blocks_count, fs->sb.s_free_blocks_count, - fs->sb.s_r_blocks_count, fs->sb.s_first_data_block); - printf("%d inodes (%d free)\n", fs->sb.s_inodes_count, - fs->sb.s_free_inodes_count); + fs->sb->s_blocks_count, fs->sb->s_free_blocks_count, + fs->sb->s_r_blocks_count, fs->sb->s_first_data_block); + printf("%d inodes (%d free)\n", fs->sb->s_inodes_count, + fs->sb->s_free_inodes_count); printf("block size = %d, frag size = %d\n", - fs->sb.s_log_block_size ? (fs->sb.s_log_block_size << 11) : 1024, - fs->sb.s_log_frag_size ? (fs->sb.s_log_frag_size << 11) : 1024); + fs->sb->s_log_block_size ? (fs->sb->s_log_block_size << 11) : 1024, + fs->sb->s_log_frag_size ? (fs->sb->s_log_frag_size << 11) : 1024); printf("number of groups: %d\n",GRP_NBGROUPS(fs)); printf("%d blocks per group,%d frags per group,%d inodes per group\n", - fs->sb.s_blocks_per_group, fs->sb.s_frags_per_group, - fs->sb.s_inodes_per_group); + fs->sb->s_blocks_per_group, fs->sb->s_frags_per_group, + fs->sb->s_inodes_per_group); printf("Size of inode table: %d blocks\n", - (int)(fs->sb.s_inodes_per_group * sizeof(inode) / BLOCKSIZE)); + (int)(fs->sb->s_inodes_per_group * sizeof(inode) / BLOCKSIZE)); for (i = 0; i < GRP_NBGROUPS(fs); i++) { printf("Group No: %d\n", i+1); + gd = get_gd(fs, i, &gi); printf("block bitmap: block %d,inode bitmap: block %d, inode table: block %d\n", - fs->gd[i].bg_block_bitmap, fs->gd[i].bg_inode_bitmap, - fs->gd[i].bg_inode_table); + gd->bg_block_bitmap, + gd->bg_inode_bitmap, + gd->bg_inode_table); printf("block bitmap allocation:\n"); - print_bm(GRP_GET_GROUP_BBM(fs, i),fs->sb.s_blocks_per_group); + print_bm(GRP_GET_GROUP_BBM(fs, gd, &bi),fs->sb->s_blocks_per_group); + GRP_PUT_GROUP_BBM(bi); printf("inode bitmap allocation:\n"); - ibm = GRP_GET_GROUP_IBM(fs, i); - print_bm(ibm, fs->sb.s_inodes_per_group); - for (i = 1; i <= fs->sb.s_inodes_per_group; i++) + ibm = GRP_GET_GROUP_IBM(fs, gd, &bi); + print_bm(ibm, fs->sb->s_inodes_per_group); + for (i = 1; i <= fs->sb->s_inodes_per_group; i++) if (allocated(ibm, i)) print_inode(fs, i); + GRP_PUT_GROUP_IBM(bi); + put_gd(gi); } } static void -dump_fs(filesystem *fs, FILE * fh, int swapit) +finish_fs(filesystem *fs) { - uint32 nbblocks = fs->sb.s_blocks_count; - fs->sb.s_reserved[200] = 0; - if(swapit) - swap_goodfs(fs); - if(fwrite(fs, BLOCKSIZE, nbblocks, fh) < nbblocks) - perror_msg_and_die("output filesystem image"); - if(swapit) - swap_badfs(fs); + if (cache_flush(&fs->inodes)) + error_msg_and_die("entry mismatch on inode cache flush"); + if (cache_flush(&fs->blkmaps)) + error_msg_and_die("entry mismatch on blockmap cache flush"); + if (cache_flush(&fs->gds)) + error_msg_and_die("entry mismatch on gd cache flush"); + if (cache_flush(&fs->blks)) + error_msg_and_die("entry mismatch on block cache flush"); + if(fs->swapit) + swap_sb(fs->sb); + if (fseek(fs->f, SUPERBLOCK_OFFSET, SEEK_SET)) + perror_msg_and_die("fseek"); + if(fwrite(fs->sb, SUPERBLOCK_SIZE, 1, fs->f) != 1) + perror_msg_and_die("output filesystem superblock"); + if(fs->swapit) + swap_sb(fs->sb); } static void @@ -2419,10 +3146,12 @@ " -x, --starting-image \n" " -d, --root \n" " -D, --devtable \n" + " -B, --block-size \n" " -b, --size-in-blocks \n" " -i, --bytes-per-inode \n" " -N, --number-of-inodes \n" " -m, --reserved-percentage \n" + " -o, --creator-os 'linux' (default), 'hurd', 'freebsd' or number.\n" " -g, --block-map Generate a block map file for this path.\n" " -e, --fill-value Fill unallocated blocks with value.\n" " -z, --allow-holes Allow files with holes.\n" @@ -2444,15 +3173,34 @@ extern char* optarg; extern int optind, opterr, optopt; +// parse the value for -o +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 +# include +#else +# if HAVE_STDLIB_H +# include +# endif +# if HAVE_STDDEF_H +# include +# 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__ */