From be66df68662f5e9afd0a034d7ccc93b077d3f543 Mon Sep 17 00:00:00 2001 From: Willy Tarreau Date: Sat, 7 Aug 2010 10:02:40 +0200 Subject: squashfs3: rename all exported macros, types and symbols to use 'squashfs3' --- fs/squashfs3/inode.c | 654 ++++++++++++++-------------- fs/squashfs3/squashfs2_0.c | 344 ++++++++-------- fs/squashfs3/squashfs3.h | 42 +- include/linux/squashfs3_fs.h | 920 +++++++++++++++++++------------------- include/linux/squashfs3_fs_i.h | 6 +- include/linux/squashfs3_fs_sb.h | 20 +- init/do_mounts_rd.c | 18 +- 7 files changed, 1002 insertions(+), 1002 deletions(-) diff --git a/fs/squashfs3/inode.c b/fs/squashfs3/inode.c index 043e0fb..fc275fc 100644 --- a/fs/squashfs3/inode.c +++ b/fs/squashfs3/inode.c @@ -42,7 +42,7 @@ static struct dentry *squashfs_fh_to_dentry(struct super_block *s, static struct dentry *squashfs_fh_to_parent(struct super_block *s, struct fid *fid, int fh_len, int fh_type); static struct dentry *squashfs_get_parent(struct dentry *child); -static int squashfs_read_inode(struct inode *i, squashfs_inode_t inode); +static int squashfs_read_inode(struct inode *i, squashfs3_inode_t inode); static int squashfs_statfs(struct dentry *, struct kstatfs *); static int squashfs_symlink_readpage(struct file *file, struct page *page); static long long read_blocklist(struct inode *inode, int index, @@ -87,11 +87,11 @@ static struct export_operations squashfs_export_ops = { .get_parent = squashfs_get_parent }; -SQSH_EXTERN const struct address_space_operations squashfs_symlink_aops = { +SQSH_EXTERN const struct address_space_operations squashfs3_symlink_aops = { .readpage = squashfs_symlink_readpage }; -SQSH_EXTERN const struct address_space_operations squashfs_aops = { +SQSH_EXTERN const struct address_space_operations squashfs3_aops = { .readpage = squashfs_readpage }; @@ -100,7 +100,7 @@ static const struct file_operations squashfs_dir_ops = { .readdir = squashfs_readdir }; -SQSH_EXTERN struct inode_operations squashfs_dir_inode_ops = { +SQSH_EXTERN struct inode_operations squashfs3_dir_inode_ops = { .lookup = squashfs_lookup }; @@ -108,7 +108,7 @@ SQSH_EXTERN struct inode_operations squashfs_dir_inode_ops = { static struct buffer_head *get_block_length(struct super_block *s, int *cur_index, int *offset, int *c_byte) { - struct squashfs_sb_info *msblk = s->s_fs_info; + struct squashfs3_sb_info *msblk = s->s_fs_info; unsigned short temp; struct buffer_head *bh; @@ -149,7 +149,7 @@ static struct buffer_head *get_block_length(struct super_block *s, *offset += 2; } - if (SQUASHFS_CHECK_DATA(msblk->sblk.flags)) { + if (SQUASHFS3_CHECK_DATA(msblk->sblk.flags)) { if (*offset == msblk->devblksize) { brelse(bh); if (!(bh = sb_bread(s, ++(*cur_index)))) @@ -157,7 +157,7 @@ static struct buffer_head *get_block_length(struct super_block *s, *offset = 0; } if (*((unsigned char *) (bh->b_data + *offset)) != - SQUASHFS_MARKER_BYTE) { + SQUASHFS3_MARKER_BYTE) { ERROR("Metadata block marker corrupt @ %x\n", *cur_index); brelse(bh); @@ -172,12 +172,12 @@ out: } -SQSH_EXTERN unsigned int squashfs_read_data(struct super_block *s, char *buffer, +SQSH_EXTERN unsigned int squashfs3_read_data(struct super_block *s, char *buffer, long long index, unsigned int length, long long *next_index, int srclength) { - struct squashfs_sb_info *msblk = s->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_sb_info *msblk = s->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; struct buffer_head **bh; unsigned int offset = index & ((1 << msblk->devblksize_log2) - 1); unsigned int cur_index = index >> msblk->devblksize_log2; @@ -192,8 +192,8 @@ SQSH_EXTERN unsigned int squashfs_read_data(struct super_block *s, char *buffer, if (c_byte) { bytes = -offset; - compressed = SQUASHFS_COMPRESSED_BLOCK(c_byte); - c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte); + compressed = SQUASHFS3_COMPRESSED_BLOCK(c_byte); + c_byte = SQUASHFS3_COMPRESSED_SIZE_BLOCK(c_byte); TRACE("Block @ 0x%llx, %scompressed size %d, src size %d\n", index, compressed ? "" : "un", (unsigned int) c_byte, srclength); @@ -218,8 +218,8 @@ SQSH_EXTERN unsigned int squashfs_read_data(struct super_block *s, char *buffer, b = 1; bytes = msblk->devblksize - offset; - compressed = SQUASHFS_COMPRESSED(c_byte); - c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte); + compressed = SQUASHFS3_COMPRESSED(c_byte); + c_byte = SQUASHFS3_COMPRESSED_SIZE(c_byte); TRACE("Block @ 0x%llx, %scompressed size %d\n", index, compressed ? "" : "un", (unsigned int) c_byte); @@ -318,7 +318,7 @@ SQSH_EXTERN unsigned int squashfs_read_data(struct super_block *s, char *buffer, if (next_index) *next_index = index + c_byte + (length ? 0 : - (SQUASHFS_CHECK_DATA(msblk->sblk.flags) ? 3 : 2)); + (SQUASHFS3_CHECK_DATA(msblk->sblk.flags) ? 3 : 2)); kfree(bh); return bytes; @@ -337,11 +337,11 @@ read_failure: } -static struct squashfs_cache_entry *squashfs_cache_get(struct super_block *s, - struct squashfs_cache *cache, long long block, int length) +static struct squashfs3_cache_entry *squashfs_cache_get(struct super_block *s, + struct squashfs3_cache *cache, long long block, int length) { int i, n; - struct squashfs_cache_entry *entry; + struct squashfs3_cache_entry *entry; spin_lock(&cache->lock); @@ -376,7 +376,7 @@ static struct squashfs_cache_entry *squashfs_cache_get(struct super_block *s, entry->error = 0; spin_unlock(&cache->lock); - entry->length = squashfs_read_data(s, entry->data, + entry->length = squashfs3_read_data(s, entry->data, block, length, &entry->next_index, cache->block_size); spin_lock(&cache->lock); @@ -416,8 +416,8 @@ out: } -static void squashfs_cache_put(struct squashfs_cache *cache, - struct squashfs_cache_entry *entry) +static void squashfs_cache_put(struct squashfs3_cache *cache, + struct squashfs3_cache_entry *entry) { spin_lock(&cache->lock); entry->locked --; @@ -431,7 +431,7 @@ static void squashfs_cache_put(struct squashfs_cache *cache, } -static void squashfs_cache_delete(struct squashfs_cache *cache) +static void squashfs_cache_delete(struct squashfs3_cache *cache) { int i; @@ -450,12 +450,12 @@ static void squashfs_cache_delete(struct squashfs_cache *cache) } -static struct squashfs_cache *squashfs_cache_init(char *name, int entries, +static struct squashfs3_cache *squashfs_cache_init(char *name, int entries, int block_size, int use_vmalloc) { int i; - struct squashfs_cache *cache = kzalloc(sizeof(struct squashfs_cache) + - entries * sizeof(struct squashfs_cache_entry), GFP_KERNEL); + struct squashfs3_cache *cache = kzalloc(sizeof(struct squashfs3_cache) + + entries * sizeof(struct squashfs3_cache_entry), GFP_KERNEL); if (cache == NULL) { ERROR("Failed to allocate %s cache\n", name); goto failed; @@ -473,7 +473,7 @@ static struct squashfs_cache *squashfs_cache_init(char *name, int entries, for (i = 0; i < entries; i++) { init_waitqueue_head(&cache->entry[i].wait_queue); - cache->entry[i].block = SQUASHFS_INVALID_BLK; + cache->entry[i].block = SQUASHFS3_INVALID_BLK; cache->entry[i].data = use_vmalloc ? vmalloc(block_size) : kmalloc(block_size, GFP_KERNEL); if (cache->entry[i].data == NULL) { @@ -491,16 +491,16 @@ failed: } -SQSH_EXTERN int squashfs_get_cached_block(struct super_block *s, void *buffer, +SQSH_EXTERN int squashfs3_get_cached_block(struct super_block *s, void *buffer, long long block, unsigned int offset, int length, long long *next_block, unsigned int *next_offset) { - struct squashfs_sb_info *msblk = s->s_fs_info; + struct squashfs3_sb_info *msblk = s->s_fs_info; int bytes, return_length = length; - struct squashfs_cache_entry *entry; + struct squashfs3_cache_entry *entry; - TRACE("Entered squashfs_get_cached_block [%llx:%x]\n", block, offset); + TRACE("Entered squashfs3_get_cached_block [%llx:%x]\n", block, offset); while (1) { entry = squashfs_cache_get(s, msblk->block_cache, block, 0); @@ -542,21 +542,21 @@ static int get_fragment_location(struct super_block *s, unsigned int fragment, long long *fragment_start_block, unsigned int *fragment_size) { - struct squashfs_sb_info *msblk = s->s_fs_info; + struct squashfs3_sb_info *msblk = s->s_fs_info; long long start_block = - msblk->fragment_index[SQUASHFS_FRAGMENT_INDEX(fragment)]; - int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET(fragment); - struct squashfs_fragment_entry fragment_entry; + msblk->fragment_index[SQUASHFS3_FRAGMENT_INDEX(fragment)]; + int offset = SQUASHFS3_FRAGMENT_INDEX_OFFSET(fragment); + struct squashfs3_fragment_entry fragment_entry; if (msblk->swap) { - struct squashfs_fragment_entry sfragment_entry; + struct squashfs3_fragment_entry sfragment_entry; - if (!squashfs_get_cached_block(s, &sfragment_entry, start_block, offset, + if (!squashfs3_get_cached_block(s, &sfragment_entry, start_block, offset, sizeof(sfragment_entry), &start_block, &offset)) goto out; - SQUASHFS_SWAP_FRAGMENT_ENTRY(&fragment_entry, &sfragment_entry); + SQUASHFS3_SWAP_FRAGMENT_ENTRY(&fragment_entry, &sfragment_entry); } else - if (!squashfs_get_cached_block(s, &fragment_entry, start_block, offset, + if (!squashfs3_get_cached_block(s, &fragment_entry, start_block, offset, sizeof(fragment_entry), &start_block, &offset)) goto out; @@ -570,25 +570,25 @@ out: } -SQSH_EXTERN void release_cached_fragment(struct squashfs_sb_info *msblk, - struct squashfs_cache_entry *fragment) +SQSH_EXTERN void release_cached_fragment(struct squashfs3_sb_info *msblk, + struct squashfs3_cache_entry *fragment) { squashfs_cache_put(msblk->fragment_cache, fragment); } SQSH_EXTERN -struct squashfs_cache_entry *get_cached_fragment(struct super_block *s, +struct squashfs3_cache_entry *get_cached_fragment(struct super_block *s, long long start_block, int length) { - struct squashfs_sb_info *msblk = s->s_fs_info; + struct squashfs3_sb_info *msblk = s->s_fs_info; return squashfs_cache_get(s, msblk->fragment_cache, start_block, length); } -static void squashfs_new_inode(struct squashfs_sb_info *msblk, struct inode *i, - struct squashfs_base_inode_header *inodeb) +static void squashfs_new_inode(struct squashfs3_sb_info *msblk, struct inode *i, + struct squashfs3_base_inode_header *inodeb) { i->i_ino = inodeb->inode_number; i->i_mtime.tv_sec = inodeb->mtime; @@ -598,30 +598,30 @@ static void squashfs_new_inode(struct squashfs_sb_info *msblk, struct inode *i, i->i_mode = inodeb->mode; i->i_size = 0; - if (inodeb->guid == SQUASHFS_GUIDS) + if (inodeb->guid == SQUASHFS3_GUIDS) i->i_gid = i->i_uid; else i->i_gid = msblk->guid[inodeb->guid]; } -static squashfs_inode_t squashfs_inode_lookup(struct super_block *s, int ino) +static squashfs3_inode_t squashfs_inode_lookup(struct super_block *s, int ino) { - struct squashfs_sb_info *msblk = s->s_fs_info; - long long start = msblk->inode_lookup_table[SQUASHFS_LOOKUP_BLOCK(ino - 1)]; - int offset = SQUASHFS_LOOKUP_BLOCK_OFFSET(ino - 1); - squashfs_inode_t inode; + struct squashfs3_sb_info *msblk = s->s_fs_info; + long long start = msblk->inode_lookup_table[SQUASHFS3_LOOKUP_BLOCK(ino - 1)]; + int offset = SQUASHFS3_LOOKUP_BLOCK_OFFSET(ino - 1); + squashfs3_inode_t inode; TRACE("Entered squashfs_inode_lookup, inode_number = %d\n", ino); if (msblk->swap) { - squashfs_inode_t sinode; + squashfs3_inode_t sinode; - if (!squashfs_get_cached_block(s, &sinode, start, offset, + if (!squashfs3_get_cached_block(s, &sinode, start, offset, sizeof(sinode), &start, &offset)) goto out; - SQUASHFS_SWAP_INODE_T((&inode), &sinode); - } else if (!squashfs_get_cached_block(s, &inode, start, offset, + SQUASHFS3_SWAP_INODE_T((&inode), &sinode); + } else if (!squashfs3_get_cached_block(s, &inode, start, offset, sizeof(inode), &start, &offset)) goto out; @@ -630,7 +630,7 @@ static squashfs_inode_t squashfs_inode_lookup(struct super_block *s, int ino) return inode; out: - return SQUASHFS_INVALID_BLK; + return SQUASHFS3_INVALID_BLK; } @@ -654,14 +654,14 @@ static inline struct dentry *d_obtain_alias(struct inode *i) static struct dentry *squashfs_export_iget(struct super_block *s, unsigned int inode_number) { - squashfs_inode_t inode; + squashfs3_inode_t inode; struct dentry *dentry = ERR_PTR(-ENOENT); TRACE("Entered squashfs_export_iget\n"); inode = squashfs_inode_lookup(s, inode_number); - if(inode != SQUASHFS_INVALID_BLK) - dentry = d_obtain_alias(squashfs_iget(s, inode, inode_number)); + if(inode != SQUASHFS3_INVALID_BLK) + dentry = d_obtain_alias(squashfs3_iget(s, inode, inode_number)); return dentry; } @@ -694,17 +694,17 @@ static struct dentry *squashfs_get_parent(struct dentry *child) TRACE("Entered squashfs_get_parent\n"); - return squashfs_export_iget(i->i_sb, SQUASHFS_I(i)->u.s2.parent_inode); + return squashfs_export_iget(i->i_sb, SQUASHFS3_I(i)->u.s2.parent_inode); } -SQSH_EXTERN struct inode *squashfs_iget(struct super_block *s, - squashfs_inode_t inode, unsigned int inode_number) +SQSH_EXTERN struct inode *squashfs3_iget(struct super_block *s, + squashfs3_inode_t inode, unsigned int inode_number) { - struct squashfs_sb_info *msblk = s->s_fs_info; + struct squashfs3_sb_info *msblk = s->s_fs_info; struct inode *i = iget_locked(s, inode_number); - TRACE("Entered squashfs_iget\n"); + TRACE("Entered squashfs3_iget\n"); if(i && (i->i_state & I_NEW)) { (msblk->read_inode)(i, inode); @@ -715,52 +715,52 @@ SQSH_EXTERN struct inode *squashfs_iget(struct super_block *s, } -static int squashfs_read_inode(struct inode *i, squashfs_inode_t inode) +static int squashfs_read_inode(struct inode *i, squashfs3_inode_t inode) { struct super_block *s = i->i_sb; - struct squashfs_sb_info *msblk = s->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; - long long block = SQUASHFS_INODE_BLK(inode) + sblk->inode_table_start; - unsigned int offset = SQUASHFS_INODE_OFFSET(inode); + struct squashfs3_sb_info *msblk = s->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; + long long block = SQUASHFS3_INODE_BLK(inode) + sblk->inode_table_start; + unsigned int offset = SQUASHFS3_INODE_OFFSET(inode); long long next_block; unsigned int next_offset; - union squashfs_inode_header id, sid; - struct squashfs_base_inode_header *inodeb = &id.base, *sinodeb = &sid.base; + union squashfs3_inode_header id, sid; + struct squashfs3_base_inode_header *inodeb = &id.base, *sinodeb = &sid.base; TRACE("Entered squashfs_read_inode\n"); if (msblk->swap) { - if (!squashfs_get_cached_block(s, sinodeb, block, offset, + if (!squashfs3_get_cached_block(s, sinodeb, block, offset, sizeof(*sinodeb), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_BASE_INODE_HEADER(inodeb, sinodeb, sizeof(*sinodeb)); + SQUASHFS3_SWAP_BASE_INODE_HEADER(inodeb, sinodeb, sizeof(*sinodeb)); } else - if (!squashfs_get_cached_block(s, inodeb, block, offset, + if (!squashfs3_get_cached_block(s, inodeb, block, offset, sizeof(*inodeb), &next_block, &next_offset)) goto failed_read; squashfs_new_inode(msblk, i, inodeb); switch(inodeb->inode_type) { - case SQUASHFS_FILE_TYPE: { + case SQUASHFS3_FILE_TYPE: { unsigned int frag_size; long long frag_blk; - struct squashfs_reg_inode_header *inodep = &id.reg; - struct squashfs_reg_inode_header *sinodep = &sid.reg; + struct squashfs3_reg_inode_header *inodep = &id.reg; + struct squashfs3_reg_inode_header *sinodep = &sid.reg; if (msblk->swap) { - if (!squashfs_get_cached_block(s, sinodep, block, offset, + if (!squashfs3_get_cached_block(s, sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_REG_INODE_HEADER(inodep, sinodep); + SQUASHFS3_SWAP_REG_INODE_HEADER(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, inodep, block, offset, + if (!squashfs3_get_cached_block(s, inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; - frag_blk = SQUASHFS_INVALID_BLK; + frag_blk = SQUASHFS3_INVALID_BLK; - if (inodep->fragment != SQUASHFS_INVALID_FRAG) + if (inodep->fragment != SQUASHFS3_INVALID_FRAG) if(!get_fragment_location(s, inodep->fragment, &frag_blk, &frag_size)) goto failed_read; @@ -770,40 +770,40 @@ static int squashfs_read_inode(struct inode *i, squashfs_inode_t inode) i->i_fop = &generic_ro_fops; i->i_mode |= S_IFREG; i->i_blocks = ((i->i_size - 1) >> 9) + 1; - SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk; - SQUASHFS_I(i)->u.s1.fragment_size = frag_size; - SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset; - SQUASHFS_I(i)->start_block = inodep->start_block; - SQUASHFS_I(i)->u.s1.block_list_start = next_block; - SQUASHFS_I(i)->offset = next_offset; - i->i_data.a_ops = &squashfs_aops; + SQUASHFS3_I(i)->u.s1.fragment_start_block = frag_blk; + SQUASHFS3_I(i)->u.s1.fragment_size = frag_size; + SQUASHFS3_I(i)->u.s1.fragment_offset = inodep->offset; + SQUASHFS3_I(i)->start_block = inodep->start_block; + SQUASHFS3_I(i)->u.s1.block_list_start = next_block; + SQUASHFS3_I(i)->offset = next_offset; + i->i_data.a_ops = &squashfs3_aops; TRACE("File inode %x:%x, start_block %llx, " "block_list_start %llx, offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, + SQUASHFS3_INODE_BLK(inode), offset, inodep->start_block, next_block, next_offset); break; } - case SQUASHFS_LREG_TYPE: { + case SQUASHFS3_LREG_TYPE: { unsigned int frag_size; long long frag_blk; - struct squashfs_lreg_inode_header *inodep = &id.lreg; - struct squashfs_lreg_inode_header *sinodep = &sid.lreg; + struct squashfs3_lreg_inode_header *inodep = &id.lreg; + struct squashfs3_lreg_inode_header *sinodep = &sid.lreg; if (msblk->swap) { - if (!squashfs_get_cached_block(s, sinodep, block, offset, + if (!squashfs3_get_cached_block(s, sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_LREG_INODE_HEADER(inodep, sinodep); + SQUASHFS3_SWAP_LREG_INODE_HEADER(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, inodep, block, offset, + if (!squashfs3_get_cached_block(s, inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; - frag_blk = SQUASHFS_INVALID_BLK; + frag_blk = SQUASHFS3_INVALID_BLK; - if (inodep->fragment != SQUASHFS_INVALID_FRAG) + if (inodep->fragment != SQUASHFS3_INVALID_FRAG) if (!get_fragment_location(s, inodep->fragment, &frag_blk, &frag_size)) goto failed_read; @@ -813,156 +813,156 @@ static int squashfs_read_inode(struct inode *i, squashfs_inode_t inode) i->i_fop = &generic_ro_fops; i->i_mode |= S_IFREG; i->i_blocks = ((i->i_size - 1) >> 9) + 1; - SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk; - SQUASHFS_I(i)->u.s1.fragment_size = frag_size; - SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset; - SQUASHFS_I(i)->start_block = inodep->start_block; - SQUASHFS_I(i)->u.s1.block_list_start = next_block; - SQUASHFS_I(i)->offset = next_offset; - i->i_data.a_ops = &squashfs_aops; + SQUASHFS3_I(i)->u.s1.fragment_start_block = frag_blk; + SQUASHFS3_I(i)->u.s1.fragment_size = frag_size; + SQUASHFS3_I(i)->u.s1.fragment_offset = inodep->offset; + SQUASHFS3_I(i)->start_block = inodep->start_block; + SQUASHFS3_I(i)->u.s1.block_list_start = next_block; + SQUASHFS3_I(i)->offset = next_offset; + i->i_data.a_ops = &squashfs3_aops; TRACE("File inode %x:%x, start_block %llx, " "block_list_start %llx, offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, + SQUASHFS3_INODE_BLK(inode), offset, inodep->start_block, next_block, next_offset); break; } - case SQUASHFS_DIR_TYPE: { - struct squashfs_dir_inode_header *inodep = &id.dir; - struct squashfs_dir_inode_header *sinodep = &sid.dir; + case SQUASHFS3_DIR_TYPE: { + struct squashfs3_dir_inode_header *inodep = &id.dir; + struct squashfs3_dir_inode_header *sinodep = &sid.dir; if (msblk->swap) { - if (!squashfs_get_cached_block(s, sinodep, block, offset, + if (!squashfs3_get_cached_block(s, sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_DIR_INODE_HEADER(inodep, sinodep); + SQUASHFS3_SWAP_DIR_INODE_HEADER(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, inodep, block, offset, + if (!squashfs3_get_cached_block(s, inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; i->i_nlink = inodep->nlink; i->i_size = inodep->file_size; - i->i_op = &squashfs_dir_inode_ops; + i->i_op = &squashfs3_dir_inode_ops; i->i_fop = &squashfs_dir_ops; i->i_mode |= S_IFDIR; - SQUASHFS_I(i)->start_block = inodep->start_block; - SQUASHFS_I(i)->offset = inodep->offset; - SQUASHFS_I(i)->u.s2.directory_index_count = 0; - SQUASHFS_I(i)->u.s2.parent_inode = inodep->parent_inode; + SQUASHFS3_I(i)->start_block = inodep->start_block; + SQUASHFS3_I(i)->offset = inodep->offset; + SQUASHFS3_I(i)->u.s2.directory_index_count = 0; + SQUASHFS3_I(i)->u.s2.parent_inode = inodep->parent_inode; TRACE("Directory inode %x:%x, start_block %x, offset " - "%x\n", SQUASHFS_INODE_BLK(inode), + "%x\n", SQUASHFS3_INODE_BLK(inode), offset, inodep->start_block, inodep->offset); break; } - case SQUASHFS_LDIR_TYPE: { - struct squashfs_ldir_inode_header *inodep = &id.ldir; - struct squashfs_ldir_inode_header *sinodep = &sid.ldir; + case SQUASHFS3_LDIR_TYPE: { + struct squashfs3_ldir_inode_header *inodep = &id.ldir; + struct squashfs3_ldir_inode_header *sinodep = &sid.ldir; if (msblk->swap) { - if (!squashfs_get_cached_block(s, sinodep, block, offset, + if (!squashfs3_get_cached_block(s, sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_LDIR_INODE_HEADER(inodep, sinodep); + SQUASHFS3_SWAP_LDIR_INODE_HEADER(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, inodep, block, offset, + if (!squashfs3_get_cached_block(s, inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; i->i_nlink = inodep->nlink; i->i_size = inodep->file_size; - i->i_op = &squashfs_dir_inode_ops; + i->i_op = &squashfs3_dir_inode_ops; i->i_fop = &squashfs_dir_ops; i->i_mode |= S_IFDIR; - SQUASHFS_I(i)->start_block = inodep->start_block; - SQUASHFS_I(i)->offset = inodep->offset; - SQUASHFS_I(i)->u.s2.directory_index_start = next_block; - SQUASHFS_I(i)->u.s2.directory_index_offset = next_offset; - SQUASHFS_I(i)->u.s2.directory_index_count = inodep->i_count; - SQUASHFS_I(i)->u.s2.parent_inode = inodep->parent_inode; + SQUASHFS3_I(i)->start_block = inodep->start_block; + SQUASHFS3_I(i)->offset = inodep->offset; + SQUASHFS3_I(i)->u.s2.directory_index_start = next_block; + SQUASHFS3_I(i)->u.s2.directory_index_offset = next_offset; + SQUASHFS3_I(i)->u.s2.directory_index_count = inodep->i_count; + SQUASHFS3_I(i)->u.s2.parent_inode = inodep->parent_inode; TRACE("Long directory inode %x:%x, start_block %x, offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, + SQUASHFS3_INODE_BLK(inode), offset, inodep->start_block, inodep->offset); break; } - case SQUASHFS_SYMLINK_TYPE: { - struct squashfs_symlink_inode_header *inodep = &id.symlink; - struct squashfs_symlink_inode_header *sinodep = &sid.symlink; + case SQUASHFS3_SYMLINK_TYPE: { + struct squashfs3_symlink_inode_header *inodep = &id.symlink; + struct squashfs3_symlink_inode_header *sinodep = &sid.symlink; if (msblk->swap) { - if (!squashfs_get_cached_block(s, sinodep, block, offset, + if (!squashfs3_get_cached_block(s, sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_SYMLINK_INODE_HEADER(inodep, sinodep); + SQUASHFS3_SWAP_SYMLINK_INODE_HEADER(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, inodep, block, offset, + if (!squashfs3_get_cached_block(s, inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; i->i_nlink = inodep->nlink; i->i_size = inodep->symlink_size; i->i_op = &page_symlink_inode_operations; - i->i_data.a_ops = &squashfs_symlink_aops; + i->i_data.a_ops = &squashfs3_symlink_aops; i->i_mode |= S_IFLNK; - SQUASHFS_I(i)->start_block = next_block; - SQUASHFS_I(i)->offset = next_offset; + SQUASHFS3_I(i)->start_block = next_block; + SQUASHFS3_I(i)->offset = next_offset; TRACE("Symbolic link inode %x:%x, start_block %llx, offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, + SQUASHFS3_INODE_BLK(inode), offset, next_block, next_offset); break; } - case SQUASHFS_BLKDEV_TYPE: - case SQUASHFS_CHRDEV_TYPE: { - struct squashfs_dev_inode_header *inodep = &id.dev; - struct squashfs_dev_inode_header *sinodep = &sid.dev; + case SQUASHFS3_BLKDEV_TYPE: + case SQUASHFS3_CHRDEV_TYPE: { + struct squashfs3_dev_inode_header *inodep = &id.dev; + struct squashfs3_dev_inode_header *sinodep = &sid.dev; if (msblk->swap) { - if (!squashfs_get_cached_block(s, sinodep, block, offset, + if (!squashfs3_get_cached_block(s, sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_DEV_INODE_HEADER(inodep, sinodep); + SQUASHFS3_SWAP_DEV_INODE_HEADER(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, inodep, block, offset, + if (!squashfs3_get_cached_block(s, inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; i->i_nlink = inodep->nlink; - i->i_mode |= (inodeb->inode_type == SQUASHFS_CHRDEV_TYPE) ? + i->i_mode |= (inodeb->inode_type == SQUASHFS3_CHRDEV_TYPE) ? S_IFCHR : S_IFBLK; init_special_inode(i, i->i_mode, old_decode_dev(inodep->rdev)); TRACE("Device inode %x:%x, rdev %x\n", - SQUASHFS_INODE_BLK(inode), offset, inodep->rdev); + SQUASHFS3_INODE_BLK(inode), offset, inodep->rdev); break; } - case SQUASHFS_FIFO_TYPE: - case SQUASHFS_SOCKET_TYPE: { - struct squashfs_ipc_inode_header *inodep = &id.ipc; - struct squashfs_ipc_inode_header *sinodep = &sid.ipc; + case SQUASHFS3_FIFO_TYPE: + case SQUASHFS3_SOCKET_TYPE: { + struct squashfs3_ipc_inode_header *inodep = &id.ipc; + struct squashfs3_ipc_inode_header *sinodep = &sid.ipc; if (msblk->swap) { - if (!squashfs_get_cached_block(s, sinodep, block, offset, + if (!squashfs3_get_cached_block(s, sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_IPC_INODE_HEADER(inodep, sinodep); + SQUASHFS3_SWAP_IPC_INODE_HEADER(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, inodep, block, offset, + if (!squashfs3_get_cached_block(s, inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; i->i_nlink = inodep->nlink; - i->i_mode |= (inodeb->inode_type == SQUASHFS_FIFO_TYPE) + i->i_mode |= (inodeb->inode_type == SQUASHFS3_FIFO_TYPE) ? S_IFIFO : S_IFSOCK; init_special_inode(i, i->i_mode, 0); break; } default: - ERROR("Unknown inode type %d in squashfs_iget!\n", + ERROR("Unknown inode type %d in squashfs3_iget!\n", inodeb->inode_type); goto failed_read1; } @@ -980,9 +980,9 @@ failed_read1: static int read_inode_lookup_table(struct super_block *s) { - struct squashfs_sb_info *msblk = s->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; - unsigned int length = SQUASHFS_LOOKUP_BLOCK_BYTES(sblk->inodes); + struct squashfs3_sb_info *msblk = s->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; + unsigned int length = SQUASHFS3_LOOKUP_BLOCK_BYTES(sblk->inodes); TRACE("In read_inode_lookup_table, length %d\n", length); @@ -993,9 +993,9 @@ static int read_inode_lookup_table(struct super_block *s) return 0; } - if (!squashfs_read_data(s, (char *) msblk->inode_lookup_table, + if (!squashfs3_read_data(s, (char *) msblk->inode_lookup_table, sblk->lookup_table_start, length | - SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, length)) { + SQUASHFS3_COMPRESSED_BIT_BLOCK, NULL, length)) { ERROR("unable to read inode lookup table\n"); return 0; } @@ -1004,9 +1004,9 @@ static int read_inode_lookup_table(struct super_block *s) int i; long long block; - for (i = 0; i < SQUASHFS_LOOKUP_BLOCKS(sblk->inodes); i++) { + for (i = 0; i < SQUASHFS3_LOOKUP_BLOCKS(sblk->inodes); i++) { /* XXX */ - SQUASHFS_SWAP_LOOKUP_BLOCKS((&block), + SQUASHFS3_SWAP_LOOKUP_BLOCKS((&block), &msblk->inode_lookup_table[i], 1); msblk->inode_lookup_table[i] = block; } @@ -1018,9 +1018,9 @@ static int read_inode_lookup_table(struct super_block *s) static int read_fragment_index_table(struct super_block *s) { - struct squashfs_sb_info *msblk = s->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; - unsigned int length = SQUASHFS_FRAGMENT_INDEX_BYTES(sblk->fragments); + struct squashfs3_sb_info *msblk = s->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; + unsigned int length = SQUASHFS3_FRAGMENT_INDEX_BYTES(sblk->fragments); if(length == 0) return 1; @@ -1032,9 +1032,9 @@ static int read_fragment_index_table(struct super_block *s) return 0; } - if (!squashfs_read_data(s, (char *) msblk->fragment_index, + if (!squashfs3_read_data(s, (char *) msblk->fragment_index, sblk->fragment_table_start, length | - SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, length)) { + SQUASHFS3_COMPRESSED_BIT_BLOCK, NULL, length)) { ERROR("unable to read fragment index table\n"); return 0; } @@ -1043,9 +1043,9 @@ static int read_fragment_index_table(struct super_block *s) int i; long long fragment; - for (i = 0; i < SQUASHFS_FRAGMENT_INDEXES(sblk->fragments); i++) { + for (i = 0; i < SQUASHFS3_FRAGMENT_INDEXES(sblk->fragments); i++) { /* XXX */ - SQUASHFS_SWAP_FRAGMENT_INDEXES((&fragment), + SQUASHFS3_SWAP_FRAGMENT_INDEXES((&fragment), &msblk->fragment_index[i], 1); msblk->fragment_index[i] = fragment; } @@ -1055,30 +1055,30 @@ static int read_fragment_index_table(struct super_block *s) } -static int supported_squashfs_filesystem(struct squashfs_sb_info *msblk, int silent) +static int supported_squashfs_filesystem(struct squashfs3_sb_info *msblk, int silent) { - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_super_block *sblk = &msblk->sblk; msblk->read_inode = squashfs_read_inode; msblk->read_blocklist = read_blocklist; msblk->read_fragment_index_table = read_fragment_index_table; if (sblk->s_major == 1) { - if (!squashfs_1_0_supported(msblk)) { + if (!squashfs3_1_0_supported(msblk)) { SERROR("Major/Minor mismatch, Squashfs 1.0 filesystems " "are unsupported\n"); SERROR("Please recompile with Squashfs 1.0 support enabled\n"); return 0; } } else if (sblk->s_major == 2) { - if (!squashfs_2_0_supported(msblk)) { + if (!squashfs3_2_0_supported(msblk)) { SERROR("Major/Minor mismatch, Squashfs 2.0 filesystems " "are unsupported\n"); SERROR("Please recompile with Squashfs 2.0 support enabled\n"); return 0; } - } else if(sblk->s_major != SQUASHFS_MAJOR || sblk->s_minor > - SQUASHFS_MINOR) { + } else if(sblk->s_major != SQUASHFS3_MAJOR || sblk->s_minor > + SQUASHFS3_MINOR) { SERROR("Major/Minor mismatch, trying to mount newer %d.%d " "filesystem\n", sblk->s_major, sblk->s_minor); SERROR("Please update your kernel\n"); @@ -1091,14 +1091,14 @@ static int supported_squashfs_filesystem(struct squashfs_sb_info *msblk, int sil static int squashfs_fill_super(struct super_block *s, void *data, int silent) { - struct squashfs_sb_info *msblk; - struct squashfs_super_block *sblk; + struct squashfs3_sb_info *msblk; + struct squashfs3_super_block *sblk; char b[BDEVNAME_SIZE]; struct inode *root; TRACE("Entered squashfs_fill_superblock\n"); - s->s_fs_info = kzalloc(sizeof(struct squashfs_sb_info), GFP_KERNEL); + s->s_fs_info = kzalloc(sizeof(struct squashfs3_sb_info), GFP_KERNEL); if (s->s_fs_info == NULL) { ERROR("Failed to allocate superblock\n"); goto failure; @@ -1119,27 +1119,27 @@ static int squashfs_fill_super(struct super_block *s, void *data, int silent) mutex_init(&msblk->read_page_mutex); mutex_init(&msblk->meta_index_mutex); - /* sblk->bytes_used is checked in squashfs_read_data to ensure reads are not - * beyond filesystem end. As we're using squashfs_read_data to read sblk here, + /* sblk->bytes_used is checked in squashfs3_read_data to ensure reads are not + * beyond filesystem end. As we're using squashfs3_read_data to read sblk here, * first set sblk->bytes_used to a useful value */ - sblk->bytes_used = sizeof(struct squashfs_super_block); - if (!squashfs_read_data(s, (char *) sblk, SQUASHFS_START, - sizeof(struct squashfs_super_block) | - SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, sizeof(struct squashfs_super_block))) { + sblk->bytes_used = sizeof(struct squashfs3_super_block); + if (!squashfs3_read_data(s, (char *) sblk, SQUASHFS3_START, + sizeof(struct squashfs3_super_block) | + SQUASHFS3_COMPRESSED_BIT_BLOCK, NULL, sizeof(struct squashfs3_super_block))) { SERROR("unable to read superblock\n"); goto failed_mount; } /* Check it is a SQUASHFS superblock */ - if ((s->s_magic = sblk->s_magic) != SQUASHFS_MAGIC) { - if (sblk->s_magic == SQUASHFS_MAGIC_SWAP) { - struct squashfs_super_block ssblk; + if ((s->s_magic = sblk->s_magic) != SQUASHFS3_MAGIC) { + if (sblk->s_magic == SQUASHFS3_MAGIC_SWAP) { + struct squashfs3_super_block ssblk; WARNING("Mounting a different endian SQUASHFS filesystem on %s\n", bdevname(s->s_bdev, b)); - SQUASHFS_SWAP_SUPER_BLOCK(&ssblk, sblk); - memcpy(sblk, &ssblk, sizeof(struct squashfs_super_block)); + SQUASHFS3_SWAP_SUPER_BLOCK(&ssblk, sblk); + memcpy(sblk, &ssblk, sizeof(struct squashfs3_super_block)); msblk->swap = 1; } else { SERROR("Can't find a SQUASHFS superblock on %s\n", @@ -1158,16 +1158,16 @@ static int squashfs_fill_super(struct super_block *s, void *data, int silent) goto failed_mount; /* Check the root inode for sanity */ - if (SQUASHFS_INODE_OFFSET(sblk->root_inode) > SQUASHFS_METADATA_SIZE) + if (SQUASHFS3_INODE_OFFSET(sblk->root_inode) > SQUASHFS3_METADATA_SIZE) goto failed_mount; TRACE("Found valid superblock on %s\n", bdevname(s->s_bdev, b)); - TRACE("Inodes are %scompressed\n", SQUASHFS_UNCOMPRESSED_INODES(sblk->flags) + TRACE("Inodes are %scompressed\n", SQUASHFS3_UNCOMPRESSED_INODES(sblk->flags) ? "un" : ""); - TRACE("Data is %scompressed\n", SQUASHFS_UNCOMPRESSED_DATA(sblk->flags) + TRACE("Data is %scompressed\n", SQUASHFS3_UNCOMPRESSED_DATA(sblk->flags) ? "un" : ""); TRACE("Check data is %spresent in the filesystem\n", - SQUASHFS_CHECK_DATA(sblk->flags) ? "" : "not "); + SQUASHFS3_CHECK_DATA(sblk->flags) ? "" : "not "); TRACE("Filesystem size %lld bytes\n", sblk->bytes_used); TRACE("Block size %d\n", sblk->block_size); TRACE("Number of inodes %d\n", sblk->inodes); @@ -1185,8 +1185,8 @@ static int squashfs_fill_super(struct super_block *s, void *data, int silent) s->s_flags |= MS_RDONLY; s->s_op = &squashfs_super_ops; - msblk->block_cache = squashfs_cache_init("metadata", SQUASHFS_CACHED_BLKS, - SQUASHFS_METADATA_SIZE, 0); + msblk->block_cache = squashfs_cache_init("metadata", SQUASHFS3_CACHED_BLKS, + SQUASHFS3_METADATA_SIZE, 0); if (msblk->block_cache == NULL) goto failed_mount; @@ -1209,31 +1209,31 @@ static int squashfs_fill_super(struct super_block *s, void *data, int silent) if (msblk->swap) { unsigned int suid[sblk->no_uids + sblk->no_guids]; - if (!squashfs_read_data(s, (char *) &suid, sblk->uid_start, + if (!squashfs3_read_data(s, (char *) &suid, sblk->uid_start, ((sblk->no_uids + sblk->no_guids) * sizeof(unsigned int)) | - SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, (sblk->no_uids + sblk->no_guids) * sizeof(unsigned int))) { + SQUASHFS3_COMPRESSED_BIT_BLOCK, NULL, (sblk->no_uids + sblk->no_guids) * sizeof(unsigned int))) { ERROR("unable to read uid/gid table\n"); goto failed_mount; } - SQUASHFS_SWAP_DATA(msblk->uid, suid, (sblk->no_uids + + SQUASHFS3_SWAP_DATA(msblk->uid, suid, (sblk->no_uids + sblk->no_guids), (sizeof(unsigned int) * 8)); } else - if (!squashfs_read_data(s, (char *) msblk->uid, sblk->uid_start, + if (!squashfs3_read_data(s, (char *) msblk->uid, sblk->uid_start, ((sblk->no_uids + sblk->no_guids) * sizeof(unsigned int)) | - SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, (sblk->no_uids + sblk->no_guids) * sizeof(unsigned int))) { + SQUASHFS3_COMPRESSED_BIT_BLOCK, NULL, (sblk->no_uids + sblk->no_guids) * sizeof(unsigned int))) { ERROR("unable to read uid/gid table\n"); goto failed_mount; } - if (sblk->s_major == 1 && squashfs_1_0_supported(msblk)) + if (sblk->s_major == 1 && squashfs3_1_0_supported(msblk)) goto allocate_root; msblk->fragment_cache = squashfs_cache_init("fragment", - SQUASHFS_CACHED_FRAGMENTS, sblk->block_size, 1); + SQUASHFS3_CACHED_FRAGMENTS, sblk->block_size, 1); if (msblk->fragment_cache == NULL) goto failed_mount; @@ -1241,7 +1241,7 @@ static int squashfs_fill_super(struct super_block *s, void *data, int silent) if (msblk->read_fragment_index_table(s) == 0) goto failed_mount; - if(sblk->s_major < 3 || sblk->lookup_table_start == SQUASHFS_INVALID_BLK) + if(sblk->s_major < 3 || sblk->lookup_table_start == SQUASHFS3_INVALID_BLK) goto allocate_root; /* Allocate and read inode lookup table */ @@ -1286,18 +1286,18 @@ failure: static int squashfs_statfs(struct dentry *dentry, struct kstatfs *buf) { - struct squashfs_sb_info *msblk = dentry->d_sb->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_sb_info *msblk = dentry->d_sb->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; TRACE("Entered squashfs_statfs\n"); - buf->f_type = SQUASHFS_MAGIC; + buf->f_type = SQUASHFS3_MAGIC; buf->f_bsize = sblk->block_size; buf->f_blocks = ((sblk->bytes_used - 1) >> sblk->block_log) + 1; buf->f_bfree = buf->f_bavail = 0; buf->f_files = sblk->inodes; buf->f_ffree = 0; - buf->f_namelen = SQUASHFS_NAME_LEN; + buf->f_namelen = SQUASHFS3_NAME_LEN; return 0; } @@ -1307,17 +1307,17 @@ static int squashfs_symlink_readpage(struct file *file, struct page *page) { struct inode *inode = page->mapping->host; int index = page->index << PAGE_CACHE_SHIFT, length, bytes, avail_bytes; - long long block = SQUASHFS_I(inode)->start_block; - int offset = SQUASHFS_I(inode)->offset; + long long block = SQUASHFS3_I(inode)->start_block; + int offset = SQUASHFS3_I(inode)->offset; void *pageaddr = kmap(page); TRACE("Entered squashfs_symlink_readpage, page index %ld, start block " "%llx, offset %x\n", page->index, - SQUASHFS_I(inode)->start_block, - SQUASHFS_I(inode)->offset); + SQUASHFS3_I(inode)->start_block, + SQUASHFS3_I(inode)->offset); for (length = 0; length < index; length += bytes) { - bytes = squashfs_get_cached_block(inode->i_sb, NULL, block, + bytes = squashfs3_get_cached_block(inode->i_sb, NULL, block, offset, PAGE_CACHE_SIZE, &block, &offset); if (bytes == 0) { ERROR("Unable to read symbolic link [%llx:%x]\n", block, offset); @@ -1333,7 +1333,7 @@ static int squashfs_symlink_readpage(struct file *file, struct page *page) avail_bytes = min_t(int, i_size_read(inode) - length, PAGE_CACHE_SIZE); - bytes = squashfs_get_cached_block(inode->i_sb, pageaddr, block, offset, + bytes = squashfs3_get_cached_block(inode->i_sb, pageaddr, block, offset, avail_bytes, &block, &offset); if (bytes == 0) ERROR("Unable to read symbolic link [%llx:%x]\n", block, offset); @@ -1352,7 +1352,7 @@ skip_read: static struct meta_index *locate_meta_index(struct inode *inode, int index, int offset) { struct meta_index *meta = NULL; - struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; + struct squashfs3_sb_info *msblk = inode->i_sb->s_fs_info; int i; mutex_lock(&msblk->meta_index_mutex); @@ -1362,7 +1362,7 @@ static struct meta_index *locate_meta_index(struct inode *inode, int index, int if (msblk->meta_index == NULL) goto not_allocated; - for (i = 0; i < SQUASHFS_META_NUMBER; i ++) { + for (i = 0; i < SQUASHFS3_META_NUMBER; i ++) { if (msblk->meta_index[i].inode_number == inode->i_ino && msblk->meta_index[i].offset >= offset && msblk->meta_index[i].offset <= index && @@ -1386,7 +1386,7 @@ not_allocated: static struct meta_index *empty_meta_index(struct inode *inode, int offset, int skip) { - struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; + struct squashfs3_sb_info *msblk = inode->i_sb->s_fs_info; struct meta_index *meta = NULL; int i; @@ -1396,22 +1396,22 @@ static struct meta_index *empty_meta_index(struct inode *inode, int offset, int if (msblk->meta_index == NULL) { msblk->meta_index = kmalloc(sizeof(struct meta_index) * - SQUASHFS_META_NUMBER, GFP_KERNEL); + SQUASHFS3_META_NUMBER, GFP_KERNEL); if (msblk->meta_index == NULL) { ERROR("Failed to allocate meta_index\n"); goto failed; } - for (i = 0; i < SQUASHFS_META_NUMBER; i++) { + for (i = 0; i < SQUASHFS3_META_NUMBER; i++) { msblk->meta_index[i].inode_number = 0; msblk->meta_index[i].locked = 0; } msblk->next_meta_index = 0; } - for (i = SQUASHFS_META_NUMBER; i && + for (i = SQUASHFS3_META_NUMBER; i && msblk->meta_index[msblk->next_meta_index].locked; i --) msblk->next_meta_index = (msblk->next_meta_index + 1) % - SQUASHFS_META_NUMBER; + SQUASHFS3_META_NUMBER; if (i == 0) { TRACE("empty_meta_index: failed!\n"); @@ -1424,7 +1424,7 @@ static struct meta_index *empty_meta_index(struct inode *inode, int offset, int meta = &msblk->meta_index[msblk->next_meta_index]; msblk->next_meta_index = (msblk->next_meta_index + 1) % - SQUASHFS_META_NUMBER; + SQUASHFS3_META_NUMBER; meta->inode_number = inode->i_ino; meta->offset = offset; @@ -1448,22 +1448,22 @@ static void release_meta_index(struct inode *inode, struct meta_index *meta) static int read_block_index(struct super_block *s, int blocks, char *block_list, long long *start_block, int *offset) { - struct squashfs_sb_info *msblk = s->s_fs_info; + struct squashfs3_sb_info *msblk = s->s_fs_info; unsigned int *block_listp; int block = 0; if (msblk->swap) { char sblock_list[blocks << 2]; - if (!squashfs_get_cached_block(s, sblock_list, *start_block, + if (!squashfs3_get_cached_block(s, sblock_list, *start_block, *offset, blocks << 2, start_block, offset)) { ERROR("Fail reading block list [%llx:%x]\n", *start_block, *offset); goto failure; } - SQUASHFS_SWAP_INTS(((unsigned int *)block_list), + SQUASHFS3_SWAP_INTS(((unsigned int *)block_list), ((unsigned int *)sblock_list), blocks); } else { - if (!squashfs_get_cached_block(s, block_list, *start_block, + if (!squashfs3_get_cached_block(s, block_list, *start_block, *offset, blocks << 2, start_block, offset)) { ERROR("Fail reading block list [%llx:%x]\n", *start_block, *offset); goto failure; @@ -1472,7 +1472,7 @@ static int read_block_index(struct super_block *s, int blocks, char *block_list, for (block_listp = (unsigned int *) block_list; blocks; block_listp++, blocks --) - block += SQUASHFS_COMPRESSED_SIZE_BLOCK(*block_listp); + block += SQUASHFS3_COMPRESSED_SIZE_BLOCK(*block_listp); return block; @@ -1484,7 +1484,7 @@ failure: #define SIZE 256 static inline int calculate_skip(int blocks) { - int skip = (blocks - 1) / ((SQUASHFS_SLOTS * SQUASHFS_META_ENTRIES + 1) * SQUASHFS_META_INDEXES); + int skip = (blocks - 1) / ((SQUASHFS3_SLOTS * SQUASHFS3_META_ENTRIES + 1) * SQUASHFS3_META_INDEXES); return skip >= 7 ? 7 : skip + 1; } @@ -1493,18 +1493,18 @@ static int get_meta_index(struct inode *inode, int index, long long *index_block, int *index_offset, long long *data_block, char *block_list) { - struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_sb_info *msblk = inode->i_sb->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; int skip = calculate_skip(i_size_read(inode) >> sblk->block_log); int offset = 0; struct meta_index *meta; struct meta_entry *meta_entry; - long long cur_index_block = SQUASHFS_I(inode)->u.s1.block_list_start; - int cur_offset = SQUASHFS_I(inode)->offset; - long long cur_data_block = SQUASHFS_I(inode)->start_block; + long long cur_index_block = SQUASHFS3_I(inode)->u.s1.block_list_start; + int cur_offset = SQUASHFS3_I(inode)->offset; + long long cur_data_block = SQUASHFS3_I(inode)->start_block; int i; - index /= SQUASHFS_META_INDEXES * skip; + index /= SQUASHFS3_META_INDEXES * skip; while (offset < index) { meta = locate_meta_index(inode, index, offset + 1); @@ -1532,8 +1532,8 @@ static int get_meta_index(struct inode *inode, int index, } for (i = meta->offset + meta->entries; i <= index && - i < meta->offset + SQUASHFS_META_ENTRIES; i++) { - int blocks = skip * SQUASHFS_META_INDEXES; + i < meta->offset + SQUASHFS3_META_ENTRIES; i++) { + int blocks = skip * SQUASHFS3_META_INDEXES; while (blocks) { int block = blocks > (SIZE >> 2) ? (SIZE >> 2) : blocks; @@ -1566,7 +1566,7 @@ all_done: *index_offset = cur_offset; *data_block = cur_data_block; - return offset * SQUASHFS_META_INDEXES * skip; + return offset * SQUASHFS3_META_INDEXES * skip; failed: release_meta_index(inode, meta); @@ -1616,15 +1616,15 @@ failure: static int squashfs_readpage(struct file *file, struct page *page) { struct inode *inode = page->mapping->host; - struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_sb_info *msblk = inode->i_sb->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; unsigned char *block_list = NULL; long long block; unsigned int bsize, i; int bytes; int index = page->index >> (sblk->block_log - PAGE_CACHE_SHIFT); void *pageaddr; - struct squashfs_cache_entry *fragment = NULL; + struct squashfs3_cache_entry *fragment = NULL; char *data_ptr = msblk->read_page; int mask = (1 << (sblk->block_log - PAGE_CACHE_SHIFT)) - 1; @@ -1634,13 +1634,13 @@ static int squashfs_readpage(struct file *file, struct page *page) int sparse = 0; TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n", - page->index, SQUASHFS_I(inode)->start_block); + page->index, SQUASHFS3_I(inode)->start_block); if (page->index >= ((i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT)) goto out; - if (SQUASHFS_I(inode)->u.s1.fragment_start_block == SQUASHFS_INVALID_BLK + if (SQUASHFS3_I(inode)->u.s1.fragment_start_block == SQUASHFS3_INVALID_BLK || index < file_end) { block_list = kmalloc(SIZE, GFP_KERNEL); if (block_list == NULL) { @@ -1659,7 +1659,7 @@ static int squashfs_readpage(struct file *file, struct page *page) } else { mutex_lock(&msblk->read_page_mutex); - bytes = squashfs_read_data(inode->i_sb, msblk->read_page, block, + bytes = squashfs3_read_data(inode->i_sb, msblk->read_page, block, bsize, NULL, sblk->block_size); if (bytes == 0) { @@ -1670,18 +1670,18 @@ static int squashfs_readpage(struct file *file, struct page *page) } } else { fragment = get_cached_fragment(inode->i_sb, - SQUASHFS_I(inode)-> u.s1.fragment_start_block, - SQUASHFS_I(inode)->u.s1.fragment_size); + SQUASHFS3_I(inode)-> u.s1.fragment_start_block, + SQUASHFS3_I(inode)->u.s1.fragment_size); if (fragment->error) { ERROR("Unable to read page, block %llx, size %x\n", - SQUASHFS_I(inode)->u.s1.fragment_start_block, - (int) SQUASHFS_I(inode)->u.s1.fragment_size); + SQUASHFS3_I(inode)->u.s1.fragment_start_block, + (int) SQUASHFS3_I(inode)->u.s1.fragment_size); release_cached_fragment(msblk, fragment); goto error_out; } bytes = i_size_read(inode) & (sblk->block_size - 1); - data_ptr = fragment->data + SQUASHFS_I(inode)->u.s1.fragment_offset; + data_ptr = fragment->data + SQUASHFS3_I(inode)->u.s1.fragment_offset; } for (i = start_index; i <= end_index && bytes > 0; i++, @@ -1712,7 +1712,7 @@ skip_page: page_cache_release(push_page); } - if (SQUASHFS_I(inode)->u.s1.fragment_start_block == SQUASHFS_INVALID_BLK + if (SQUASHFS3_I(inode)->u.s1.fragment_start_block == SQUASHFS3_INVALID_BLK || index < file_end) { if (!sparse) mutex_unlock(&msblk->read_page_mutex); @@ -1743,10 +1743,10 @@ static int get_dir_index_using_offset(struct super_block *s, long long index_start, unsigned int index_offset, int i_count, long long f_pos) { - struct squashfs_sb_info *msblk = s->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_sb_info *msblk = s->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; int i, length = 0; - struct squashfs_dir_index index; + struct squashfs3_dir_index index; TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %d\n", i_count, (unsigned int) f_pos); @@ -1757,25 +1757,25 @@ static int get_dir_index_using_offset(struct super_block *s, for (i = 0; i < i_count; i++) { if (msblk->swap) { - struct squashfs_dir_index sindex; - squashfs_get_cached_block(s, &sindex, index_start, index_offset, + struct squashfs3_dir_index sindex; + squashfs3_get_cached_block(s, &sindex, index_start, index_offset, sizeof(sindex), &index_start, &index_offset); - SQUASHFS_SWAP_DIR_INDEX(&index, &sindex); + SQUASHFS3_SWAP_DIR_INDEX(&index, &sindex); } else - squashfs_get_cached_block(s, &index, index_start, index_offset, + squashfs3_get_cached_block(s, &index, index_start, index_offset, sizeof(index), &index_start, &index_offset); if (index.index > f_pos) break; - squashfs_get_cached_block(s, NULL, index_start, index_offset, + squashfs3_get_cached_block(s, NULL, index_start, index_offset, index.size + 1, &index_start, &index_offset); length = index.index; *next_block = index.start_block + sblk->directory_table_start; } - *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE; + *next_offset = (length + *next_offset) % SQUASHFS3_METADATA_SIZE; finish: return length + 3; @@ -1787,36 +1787,36 @@ static int get_dir_index_using_name(struct super_block *s, long long index_start, unsigned int index_offset, int i_count, const char *name, int size) { - struct squashfs_sb_info *msblk = s->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_sb_info *msblk = s->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; int i, length = 0; - struct squashfs_dir_index *index; + struct squashfs3_dir_index *index; char *str; TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count); - str = kmalloc(sizeof(struct squashfs_dir_index) + - (SQUASHFS_NAME_LEN + 1) * 2, GFP_KERNEL); + str = kmalloc(sizeof(struct squashfs3_dir_index) + + (SQUASHFS3_NAME_LEN + 1) * 2, GFP_KERNEL); if (str == NULL) { - ERROR("Failed to allocate squashfs_dir_index\n"); + ERROR("Failed to allocate squashfs3_dir_index\n"); goto failure; } - index = (struct squashfs_dir_index *) (str + SQUASHFS_NAME_LEN + 1); + index = (struct squashfs3_dir_index *) (str + SQUASHFS3_NAME_LEN + 1); strncpy(str, name, size); str[size] = '\0'; for (i = 0; i < i_count; i++) { if (msblk->swap) { - struct squashfs_dir_index sindex; - squashfs_get_cached_block(s, &sindex, index_start, index_offset, + struct squashfs3_dir_index sindex; + squashfs3_get_cached_block(s, &sindex, index_start, index_offset, sizeof(sindex), &index_start, &index_offset); - SQUASHFS_SWAP_DIR_INDEX(index, &sindex); + SQUASHFS3_SWAP_DIR_INDEX(index, &sindex); } else - squashfs_get_cached_block(s, index, index_start, index_offset, - sizeof(struct squashfs_dir_index), &index_start, &index_offset); + squashfs3_get_cached_block(s, index, index_start, index_offset, + sizeof(struct squashfs3_dir_index), &index_start, &index_offset); - squashfs_get_cached_block(s, index->name, index_start, index_offset, + squashfs3_get_cached_block(s, index->name, index_start, index_offset, index->size + 1, &index_start, &index_offset); index->name[index->size + 1] = '\0'; @@ -1828,7 +1828,7 @@ static int get_dir_index_using_name(struct super_block *s, *next_block = index->start_block + sblk->directory_table_start; } - *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE; + *next_offset = (length + *next_offset) % SQUASHFS3_METADATA_SIZE; kfree(str); failure: @@ -1839,20 +1839,20 @@ failure: static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir) { struct inode *i = file->f_dentry->d_inode; - struct squashfs_sb_info *msblk = i->i_sb->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; - long long next_block = SQUASHFS_I(i)->start_block + + struct squashfs3_sb_info *msblk = i->i_sb->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; + long long next_block = SQUASHFS3_I(i)->start_block + sblk->directory_table_start; - int next_offset = SQUASHFS_I(i)->offset, length = 0, dir_count; - struct squashfs_dir_header dirh; - struct squashfs_dir_entry *dire; + int next_offset = SQUASHFS3_I(i)->offset, length = 0, dir_count; + struct squashfs3_dir_header dirh; + struct squashfs3_dir_entry *dire; TRACE("Entered squashfs_readdir [%llx:%x]\n", next_block, next_offset); - dire = kmalloc(sizeof(struct squashfs_dir_entry) + - SQUASHFS_NAME_LEN + 1, GFP_KERNEL); + dire = kmalloc(sizeof(struct squashfs3_dir_entry) + + SQUASHFS3_NAME_LEN + 1, GFP_KERNEL); if (dire == NULL) { - ERROR("Failed to allocate squashfs_dir_entry\n"); + ERROR("Failed to allocate squashfs3_dir_entry\n"); goto finish; } @@ -1867,7 +1867,7 @@ static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir) } else { name = ".."; size = 2; - i_ino = SQUASHFS_I(i)->u.s2.parent_inode; + i_ino = SQUASHFS3_I(i)->u.s2.parent_inode; } TRACE("Calling filldir(%x, %s, %d, %d, %d, %d)\n", (unsigned int) dirent, name, size, (int) @@ -1882,23 +1882,23 @@ static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir) } length = get_dir_index_using_offset(i->i_sb, &next_block, &next_offset, - SQUASHFS_I(i)->u.s2.directory_index_start, - SQUASHFS_I(i)->u.s2.directory_index_offset, - SQUASHFS_I(i)->u.s2.directory_index_count, file->f_pos); + SQUASHFS3_I(i)->u.s2.directory_index_start, + SQUASHFS3_I(i)->u.s2.directory_index_offset, + SQUASHFS3_I(i)->u.s2.directory_index_count, file->f_pos); while (length < i_size_read(i)) { /* read directory header */ if (msblk->swap) { - struct squashfs_dir_header sdirh; + struct squashfs3_dir_header sdirh; - if (!squashfs_get_cached_block(i->i_sb, &sdirh, next_block, + if (!squashfs3_get_cached_block(i->i_sb, &sdirh, next_block, next_offset, sizeof(sdirh), &next_block, &next_offset)) goto failed_read; length += sizeof(sdirh); - SQUASHFS_SWAP_DIR_HEADER(&dirh, &sdirh); + SQUASHFS3_SWAP_DIR_HEADER(&dirh, &sdirh); } else { - if (!squashfs_get_cached_block(i->i_sb, &dirh, next_block, + if (!squashfs3_get_cached_block(i->i_sb, &dirh, next_block, next_offset, sizeof(dirh), &next_block, &next_offset)) goto failed_read; @@ -1908,22 +1908,22 @@ static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir) dir_count = dirh.count + 1; while (dir_count--) { if (msblk->swap) { - struct squashfs_dir_entry sdire; - if (!squashfs_get_cached_block(i->i_sb, &sdire, next_block, + struct squashfs3_dir_entry sdire; + if (!squashfs3_get_cached_block(i->i_sb, &sdire, next_block, next_offset, sizeof(sdire), &next_block, &next_offset)) goto failed_read; length += sizeof(sdire); - SQUASHFS_SWAP_DIR_ENTRY(dire, &sdire); + SQUASHFS3_SWAP_DIR_ENTRY(dire, &sdire); } else { - if (!squashfs_get_cached_block(i->i_sb, dire, next_block, + if (!squashfs3_get_cached_block(i->i_sb, dire, next_block, next_offset, sizeof(*dire), &next_block, &next_offset)) goto failed_read; length += sizeof(*dire); } - if (!squashfs_get_cached_block(i->i_sb, dire->name, next_block, + if (!squashfs3_get_cached_block(i->i_sb, dire->name, next_block, next_offset, dire->size + 1, &next_block, &next_offset)) goto failed_read; @@ -1968,43 +1968,43 @@ static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry, const unsigned char *name = dentry->d_name.name; int len = dentry->d_name.len; struct inode *inode = NULL; - struct squashfs_sb_info *msblk = i->i_sb->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; - long long next_block = SQUASHFS_I(i)->start_block + + struct squashfs3_sb_info *msblk = i->i_sb->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; + long long next_block = SQUASHFS3_I(i)->start_block + sblk->directory_table_start; - int next_offset = SQUASHFS_I(i)->offset, length = 0, dir_count; - struct squashfs_dir_header dirh; - struct squashfs_dir_entry *dire; + int next_offset = SQUASHFS3_I(i)->offset, length = 0, dir_count; + struct squashfs3_dir_header dirh; + struct squashfs3_dir_entry *dire; TRACE("Entered squashfs_lookup [%llx:%x]\n", next_block, next_offset); - dire = kmalloc(sizeof(struct squashfs_dir_entry) + - SQUASHFS_NAME_LEN + 1, GFP_KERNEL); + dire = kmalloc(sizeof(struct squashfs3_dir_entry) + + SQUASHFS3_NAME_LEN + 1, GFP_KERNEL); if (dire == NULL) { - ERROR("Failed to allocate squashfs_dir_entry\n"); + ERROR("Failed to allocate squashfs3_dir_entry\n"); goto exit_lookup; } - if (len > SQUASHFS_NAME_LEN) + if (len > SQUASHFS3_NAME_LEN) goto exit_lookup; length = get_dir_index_using_name(i->i_sb, &next_block, &next_offset, - SQUASHFS_I(i)->u.s2.directory_index_start, - SQUASHFS_I(i)->u.s2.directory_index_offset, - SQUASHFS_I(i)->u.s2.directory_index_count, name, len); + SQUASHFS3_I(i)->u.s2.directory_index_start, + SQUASHFS3_I(i)->u.s2.directory_index_offset, + SQUASHFS3_I(i)->u.s2.directory_index_count, name, len); while (length < i_size_read(i)) { /* read directory header */ if (msblk->swap) { - struct squashfs_dir_header sdirh; - if (!squashfs_get_cached_block(i->i_sb, &sdirh, next_block, + struct squashfs3_dir_header sdirh; + if (!squashfs3_get_cached_block(i->i_sb, &sdirh, next_block, next_offset, sizeof(sdirh), &next_block, &next_offset)) goto failed_read; length += sizeof(sdirh); - SQUASHFS_SWAP_DIR_HEADER(&dirh, &sdirh); + SQUASHFS3_SWAP_DIR_HEADER(&dirh, &sdirh); } else { - if (!squashfs_get_cached_block(i->i_sb, &dirh, next_block, + if (!squashfs3_get_cached_block(i->i_sb, &dirh, next_block, next_offset, sizeof(dirh), &next_block, &next_offset)) goto failed_read; @@ -2014,22 +2014,22 @@ static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry, dir_count = dirh.count + 1; while (dir_count--) { if (msblk->swap) { - struct squashfs_dir_entry sdire; - if (!squashfs_get_cached_block(i->i_sb, &sdire, next_block, + struct squashfs3_dir_entry sdire; + if (!squashfs3_get_cached_block(i->i_sb, &sdire, next_block, next_offset, sizeof(sdire), &next_block, &next_offset)) goto failed_read; length += sizeof(sdire); - SQUASHFS_SWAP_DIR_ENTRY(dire, &sdire); + SQUASHFS3_SWAP_DIR_ENTRY(dire, &sdire); } else { - if (!squashfs_get_cached_block(i->i_sb, dire, next_block, + if (!squashfs3_get_cached_block(i->i_sb, dire, next_block, next_offset, sizeof(*dire), &next_block, &next_offset)) goto failed_read; length += sizeof(*dire); } - if (!squashfs_get_cached_block(i->i_sb, dire->name, next_block, + if (!squashfs3_get_cached_block(i->i_sb, dire->name, next_block, next_offset, dire->size + 1, &next_block, &next_offset)) goto failed_read; @@ -2039,14 +2039,14 @@ static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry, goto exit_lookup; if ((len == dire->size + 1) && !strncmp(name, dire->name, len)) { - squashfs_inode_t ino = SQUASHFS_MKINODE(dirh.start_block, + squashfs3_inode_t ino = SQUASHFS3_MKINODE(dirh.start_block, dire->offset); - TRACE("calling squashfs_iget for directory entry %s, inode" + TRACE("calling squashfs3_iget for directory entry %s, inode" " %x:%x, %d\n", name, dirh.start_block, dire->offset, dirh.inode_number + dire->inode_number); - inode = squashfs_iget(i->i_sb, ino, dirh.inode_number + dire->inode_number); + inode = squashfs3_iget(i->i_sb, ino, dirh.inode_number + dire->inode_number); goto exit_lookup; } @@ -2077,7 +2077,7 @@ static int squashfs_remount(struct super_block *s, int *flags, char *data) static void squashfs_put_super(struct super_block *s) { if (s->s_fs_info) { - struct squashfs_sb_info *sbi = s->s_fs_info; + struct squashfs3_sb_info *sbi = s->s_fs_info; squashfs_cache_delete(sbi->block_cache); squashfs_cache_delete(sbi->fragment_cache); vfree(sbi->read_page); @@ -2130,7 +2130,7 @@ static struct kmem_cache * squashfs_inode_cachep; static struct inode *squashfs_alloc_inode(struct super_block *sb) { - struct squashfs_inode_info *ei; + struct squashfs3_inode_info *ei; ei = kmem_cache_alloc(squashfs_inode_cachep, GFP_KERNEL); return ei ? &ei->vfs_inode : NULL; } @@ -2138,13 +2138,13 @@ static struct inode *squashfs_alloc_inode(struct super_block *sb) static void squashfs_destroy_inode(struct inode *inode) { - kmem_cache_free(squashfs_inode_cachep, SQUASHFS_I(inode)); + kmem_cache_free(squashfs_inode_cachep, SQUASHFS3_I(inode)); } static void init_once(void *foo) { - struct squashfs_inode_info *ei = foo; + struct squashfs3_inode_info *ei = foo; inode_init_once(&ei->vfs_inode); } @@ -2153,7 +2153,7 @@ static void init_once(void *foo) static int __init init_inodecache(void) { squashfs_inode_cachep = kmem_cache_create("squashfs_inode_cache", - sizeof(struct squashfs_inode_info), 0, + sizeof(struct squashfs3_inode_info), 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT, init_once); if (squashfs_inode_cachep == NULL) return -ENOMEM; diff --git a/fs/squashfs3/squashfs2_0.c b/fs/squashfs3/squashfs2_0.c index e8f461c..0cc9b7a 100644 --- a/fs/squashfs3/squashfs2_0.c +++ b/fs/squashfs3/squashfs2_0.c @@ -38,7 +38,7 @@ static struct file_operations squashfs_dir_ops_2 = { .readdir = squashfs_readdir_2 }; -static struct inode_operations squashfs_dir_inode_ops_2 = { +static struct inode_operations squashfs3_dir_inode_ops_2 = { .lookup = squashfs_lookup_2 }; @@ -48,22 +48,22 @@ static unsigned char squashfs_filetype_table[] = { static int read_fragment_index_table_2(struct super_block *s) { - struct squashfs_sb_info *msblk = s->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_sb_info *msblk = s->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; - if (!(msblk->fragment_index_2 = kmalloc(SQUASHFS_FRAGMENT_INDEX_BYTES_2 + if (!(msblk->fragment_index_2 = kmalloc(SQUASHFS3_FRAGMENT_INDEX_BYTES_2 (sblk->fragments), GFP_KERNEL))) { ERROR("Failed to allocate uid/gid table\n"); return 0; } - if (SQUASHFS_FRAGMENT_INDEX_BYTES_2(sblk->fragments) && - !squashfs_read_data(s, (char *) + if (SQUASHFS3_FRAGMENT_INDEX_BYTES_2(sblk->fragments) && + !squashfs3_read_data(s, (char *) msblk->fragment_index_2, sblk->fragment_table_start, - SQUASHFS_FRAGMENT_INDEX_BYTES_2 + SQUASHFS3_FRAGMENT_INDEX_BYTES_2 (sblk->fragments) | - SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, SQUASHFS_FRAGMENT_INDEX_BYTES_2(sblk->fragments))) { + SQUASHFS3_COMPRESSED_BIT_BLOCK, NULL, SQUASHFS3_FRAGMENT_INDEX_BYTES_2(sblk->fragments))) { ERROR("unable to read fragment index table\n"); return 0; } @@ -72,9 +72,9 @@ static int read_fragment_index_table_2(struct super_block *s) int i; unsigned int fragment; - for (i = 0; i < SQUASHFS_FRAGMENT_INDEXES_2(sblk->fragments); + for (i = 0; i < SQUASHFS3_FRAGMENT_INDEXES_2(sblk->fragments); i++) { - SQUASHFS_SWAP_FRAGMENT_INDEXES_2((&fragment), + SQUASHFS3_SWAP_FRAGMENT_INDEXES_2((&fragment), &msblk->fragment_index_2[i], 1); msblk->fragment_index_2[i] = fragment; } @@ -88,23 +88,23 @@ static int get_fragment_location_2(struct super_block *s, unsigned int fragment, long long *fragment_start_block, unsigned int *fragment_size) { - struct squashfs_sb_info *msblk = s->s_fs_info; + struct squashfs3_sb_info *msblk = s->s_fs_info; long long start_block = - msblk->fragment_index_2[SQUASHFS_FRAGMENT_INDEX_2(fragment)]; - int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET_2(fragment); - struct squashfs_fragment_entry_2 fragment_entry; + msblk->fragment_index_2[SQUASHFS3_FRAGMENT_INDEX_2(fragment)]; + int offset = SQUASHFS3_FRAGMENT_INDEX_OFFSET_2(fragment); + struct squashfs3_fragment_entry_2 fragment_entry; if (msblk->swap) { - struct squashfs_fragment_entry_2 sfragment_entry; + struct squashfs3_fragment_entry_2 sfragment_entry; - if (!squashfs_get_cached_block(s, (char *) &sfragment_entry, + if (!squashfs3_get_cached_block(s, (char *) &sfragment_entry, start_block, offset, sizeof(sfragment_entry), &start_block, &offset)) goto out; - SQUASHFS_SWAP_FRAGMENT_ENTRY_2(&fragment_entry, &sfragment_entry); + SQUASHFS3_SWAP_FRAGMENT_ENTRY_2(&fragment_entry, &sfragment_entry); } else - if (!squashfs_get_cached_block(s, (char *) &fragment_entry, + if (!squashfs3_get_cached_block(s, (char *) &fragment_entry, start_block, offset, sizeof(fragment_entry), &start_block, &offset)) @@ -120,10 +120,10 @@ out: } -static void squashfs_new_inode(struct squashfs_sb_info *msblk, struct inode *i, - struct squashfs_base_inode_header_2 *inodeb, unsigned int ino) +static void squashfs_new_inode(struct squashfs3_sb_info *msblk, struct inode *i, + struct squashfs3_base_inode_header_2 *inodeb, unsigned int ino) { - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_super_block *sblk = &msblk->sblk; i->i_ino = ino; i->i_mtime.tv_sec = sblk->mkfs_time; @@ -133,40 +133,40 @@ static void squashfs_new_inode(struct squashfs_sb_info *msblk, struct inode *i, i->i_mode = inodeb->mode; i->i_nlink = 1; i->i_size = 0; - if (inodeb->guid == SQUASHFS_GUIDS) + if (inodeb->guid == SQUASHFS3_GUIDS) i->i_gid = i->i_uid; else i->i_gid = msblk->guid[inodeb->guid]; } -static int squashfs_read_inode_2(struct inode *i, squashfs_inode_t inode) +static int squashfs_read_inode_2(struct inode *i, squashfs3_inode_t inode) { struct super_block *s = i->i_sb; - struct squashfs_sb_info *msblk = s->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; - unsigned int block = SQUASHFS_INODE_BLK(inode) + + struct squashfs3_sb_info *msblk = s->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; + unsigned int block = SQUASHFS3_INODE_BLK(inode) + sblk->inode_table_start; - unsigned int offset = SQUASHFS_INODE_OFFSET(inode); - unsigned int ino = SQUASHFS_MK_VFS_INODE(block - + unsigned int offset = SQUASHFS3_INODE_OFFSET(inode); + unsigned int ino = SQUASHFS3_MK_VFS_INODE(block - sblk->inode_table_start, offset); long long next_block; unsigned int next_offset; - union squashfs_inode_header_2 id, sid; - struct squashfs_base_inode_header_2 *inodeb = &id.base, + union squashfs3_inode_header_2 id, sid; + struct squashfs3_base_inode_header_2 *inodeb = &id.base, *sinodeb = &sid.base; TRACE("Entered squashfs_read_inode_2\n"); if (msblk->swap) { - if (!squashfs_get_cached_block(s, (char *) sinodeb, block, + if (!squashfs3_get_cached_block(s, (char *) sinodeb, block, offset, sizeof(*sinodeb), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_BASE_INODE_HEADER_2(inodeb, sinodeb, + SQUASHFS3_SWAP_BASE_INODE_HEADER_2(inodeb, sinodeb, sizeof(*sinodeb)); } else - if (!squashfs_get_cached_block(s, (char *) inodeb, block, + if (!squashfs3_get_cached_block(s, (char *) inodeb, block, offset, sizeof(*inodeb), &next_block, &next_offset)) goto failed_read; @@ -174,28 +174,28 @@ static int squashfs_read_inode_2(struct inode *i, squashfs_inode_t inode) squashfs_new_inode(msblk, i, inodeb, ino); switch(inodeb->inode_type) { - case SQUASHFS_FILE_TYPE: { - struct squashfs_reg_inode_header_2 *inodep = &id.reg; - struct squashfs_reg_inode_header_2 *sinodep = &sid.reg; + case SQUASHFS3_FILE_TYPE: { + struct squashfs3_reg_inode_header_2 *inodep = &id.reg; + struct squashfs3_reg_inode_header_2 *sinodep = &sid.reg; long long frag_blk; unsigned int frag_size = 0; if (msblk->swap) { - if (!squashfs_get_cached_block(s, (char *) + if (!squashfs3_get_cached_block(s, (char *) sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_REG_INODE_HEADER_2(inodep, sinodep); + SQUASHFS3_SWAP_REG_INODE_HEADER_2(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, (char *) + if (!squashfs3_get_cached_block(s, (char *) inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; - frag_blk = SQUASHFS_INVALID_BLK; - if (inodep->fragment != SQUASHFS_INVALID_FRAG && + frag_blk = SQUASHFS3_INVALID_BLK; + if (inodep->fragment != SQUASHFS3_INVALID_FRAG && !get_fragment_location_2(s, inodep->fragment, &frag_blk, &frag_size)) goto failed_read; @@ -207,114 +207,114 @@ static int squashfs_read_inode_2(struct inode *i, squashfs_inode_t inode) i->i_atime.tv_sec = inodep->mtime; i->i_ctime.tv_sec = inodep->mtime; i->i_blocks = ((i->i_size - 1) >> 9) + 1; - SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk; - SQUASHFS_I(i)->u.s1.fragment_size = frag_size; - SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset; - SQUASHFS_I(i)->start_block = inodep->start_block; - SQUASHFS_I(i)->u.s1.block_list_start = next_block; - SQUASHFS_I(i)->offset = next_offset; - i->i_data.a_ops = &squashfs_aops; + SQUASHFS3_I(i)->u.s1.fragment_start_block = frag_blk; + SQUASHFS3_I(i)->u.s1.fragment_size = frag_size; + SQUASHFS3_I(i)->u.s1.fragment_offset = inodep->offset; + SQUASHFS3_I(i)->start_block = inodep->start_block; + SQUASHFS3_I(i)->u.s1.block_list_start = next_block; + SQUASHFS3_I(i)->offset = next_offset; + i->i_data.a_ops = &squashfs3_aops; TRACE("File inode %x:%x, start_block %x, " "block_list_start %llx, offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, + SQUASHFS3_INODE_BLK(inode), offset, inodep->start_block, next_block, next_offset); break; } - case SQUASHFS_DIR_TYPE: { - struct squashfs_dir_inode_header_2 *inodep = &id.dir; - struct squashfs_dir_inode_header_2 *sinodep = &sid.dir; + case SQUASHFS3_DIR_TYPE: { + struct squashfs3_dir_inode_header_2 *inodep = &id.dir; + struct squashfs3_dir_inode_header_2 *sinodep = &sid.dir; if (msblk->swap) { - if (!squashfs_get_cached_block(s, (char *) + if (!squashfs3_get_cached_block(s, (char *) sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_DIR_INODE_HEADER_2(inodep, sinodep); + SQUASHFS3_SWAP_DIR_INODE_HEADER_2(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, (char *) + if (!squashfs3_get_cached_block(s, (char *) inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; i->i_size = inodep->file_size; - i->i_op = &squashfs_dir_inode_ops_2; + i->i_op = &squashfs3_dir_inode_ops_2; i->i_fop = &squashfs_dir_ops_2; i->i_mode |= S_IFDIR; i->i_mtime.tv_sec = inodep->mtime; i->i_atime.tv_sec = inodep->mtime; i->i_ctime.tv_sec = inodep->mtime; - SQUASHFS_I(i)->start_block = inodep->start_block; - SQUASHFS_I(i)->offset = inodep->offset; - SQUASHFS_I(i)->u.s2.directory_index_count = 0; - SQUASHFS_I(i)->u.s2.parent_inode = 0; + SQUASHFS3_I(i)->start_block = inodep->start_block; + SQUASHFS3_I(i)->offset = inodep->offset; + SQUASHFS3_I(i)->u.s2.directory_index_count = 0; + SQUASHFS3_I(i)->u.s2.parent_inode = 0; TRACE("Directory inode %x:%x, start_block %x, offset " - "%x\n", SQUASHFS_INODE_BLK(inode), + "%x\n", SQUASHFS3_INODE_BLK(inode), offset, inodep->start_block, inodep->offset); break; } - case SQUASHFS_LDIR_TYPE: { - struct squashfs_ldir_inode_header_2 *inodep = &id.ldir; - struct squashfs_ldir_inode_header_2 *sinodep = &sid.ldir; + case SQUASHFS3_LDIR_TYPE: { + struct squashfs3_ldir_inode_header_2 *inodep = &id.ldir; + struct squashfs3_ldir_inode_header_2 *sinodep = &sid.ldir; if (msblk->swap) { - if (!squashfs_get_cached_block(s, (char *) + if (!squashfs3_get_cached_block(s, (char *) sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_LDIR_INODE_HEADER_2(inodep, + SQUASHFS3_SWAP_LDIR_INODE_HEADER_2(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, (char *) + if (!squashfs3_get_cached_block(s, (char *) inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; i->i_size = inodep->file_size; - i->i_op = &squashfs_dir_inode_ops_2; + i->i_op = &squashfs3_dir_inode_ops_2; i->i_fop = &squashfs_dir_ops_2; i->i_mode |= S_IFDIR; i->i_mtime.tv_sec = inodep->mtime; i->i_atime.tv_sec = inodep->mtime; i->i_ctime.tv_sec = inodep->mtime; - SQUASHFS_I(i)->start_block = inodep->start_block; - SQUASHFS_I(i)->offset = inodep->offset; - SQUASHFS_I(i)->u.s2.directory_index_start = next_block; - SQUASHFS_I(i)->u.s2.directory_index_offset = + SQUASHFS3_I(i)->start_block = inodep->start_block; + SQUASHFS3_I(i)->offset = inodep->offset; + SQUASHFS3_I(i)->u.s2.directory_index_start = next_block; + SQUASHFS3_I(i)->u.s2.directory_index_offset = next_offset; - SQUASHFS_I(i)->u.s2.directory_index_count = + SQUASHFS3_I(i)->u.s2.directory_index_count = inodep->i_count; - SQUASHFS_I(i)->u.s2.parent_inode = 0; + SQUASHFS3_I(i)->u.s2.parent_inode = 0; TRACE("Long directory inode %x:%x, start_block %x, " "offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, + SQUASHFS3_INODE_BLK(inode), offset, inodep->start_block, inodep->offset); break; } - case SQUASHFS_SYMLINK_TYPE: { - struct squashfs_symlink_inode_header_2 *inodep = + case SQUASHFS3_SYMLINK_TYPE: { + struct squashfs3_symlink_inode_header_2 *inodep = &id.symlink; - struct squashfs_symlink_inode_header_2 *sinodep = + struct squashfs3_symlink_inode_header_2 *sinodep = &sid.symlink; if (msblk->swap) { - if (!squashfs_get_cached_block(s, (char *) + if (!squashfs3_get_cached_block(s, (char *) sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(inodep, + SQUASHFS3_SWAP_SYMLINK_INODE_HEADER_2(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, (char *) + if (!squashfs3_get_cached_block(s, (char *) inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) @@ -322,57 +322,57 @@ static int squashfs_read_inode_2(struct inode *i, squashfs_inode_t inode) i->i_size = inodep->symlink_size; i->i_op = &page_symlink_inode_operations; - i->i_data.a_ops = &squashfs_symlink_aops; + i->i_data.a_ops = &squashfs3_symlink_aops; i->i_mode |= S_IFLNK; - SQUASHFS_I(i)->start_block = next_block; - SQUASHFS_I(i)->offset = next_offset; + SQUASHFS3_I(i)->start_block = next_block; + SQUASHFS3_I(i)->offset = next_offset; TRACE("Symbolic link inode %x:%x, start_block %llx, " "offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, + SQUASHFS3_INODE_BLK(inode), offset, next_block, next_offset); break; } - case SQUASHFS_BLKDEV_TYPE: - case SQUASHFS_CHRDEV_TYPE: { - struct squashfs_dev_inode_header_2 *inodep = &id.dev; - struct squashfs_dev_inode_header_2 *sinodep = &sid.dev; + case SQUASHFS3_BLKDEV_TYPE: + case SQUASHFS3_CHRDEV_TYPE: { + struct squashfs3_dev_inode_header_2 *inodep = &id.dev; + struct squashfs3_dev_inode_header_2 *sinodep = &sid.dev; if (msblk->swap) { - if (!squashfs_get_cached_block(s, (char *) + if (!squashfs3_get_cached_block(s, (char *) sinodep, block, offset, sizeof(*sinodep), &next_block, &next_offset)) goto failed_read; - SQUASHFS_SWAP_DEV_INODE_HEADER_2(inodep, sinodep); + SQUASHFS3_SWAP_DEV_INODE_HEADER_2(inodep, sinodep); } else - if (!squashfs_get_cached_block(s, (char *) + if (!squashfs3_get_cached_block(s, (char *) inodep, block, offset, sizeof(*inodep), &next_block, &next_offset)) goto failed_read; i->i_mode |= (inodeb->inode_type == - SQUASHFS_CHRDEV_TYPE) ? S_IFCHR : + SQUASHFS3_CHRDEV_TYPE) ? S_IFCHR : S_IFBLK; init_special_inode(i, i->i_mode, old_decode_dev(inodep->rdev)); TRACE("Device inode %x:%x, rdev %x\n", - SQUASHFS_INODE_BLK(inode), offset, + SQUASHFS3_INODE_BLK(inode), offset, inodep->rdev); break; } - case SQUASHFS_FIFO_TYPE: - case SQUASHFS_SOCKET_TYPE: { + case SQUASHFS3_FIFO_TYPE: + case SQUASHFS3_SOCKET_TYPE: { - i->i_mode |= (inodeb->inode_type == SQUASHFS_FIFO_TYPE) + i->i_mode |= (inodeb->inode_type == SQUASHFS3_FIFO_TYPE) ? S_IFIFO : S_IFSOCK; init_special_inode(i, i->i_mode, 0); break; } default: - ERROR("Unknown inode type %d in squashfs_iget!\n", + ERROR("Unknown inode type %d in squashfs3_iget!\n", inodeb->inode_type); goto failed_read1; } @@ -393,10 +393,10 @@ static int get_dir_index_using_offset(struct super_block *s, long long unsigned int index_offset, int i_count, long long f_pos) { - struct squashfs_sb_info *msblk = s->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_sb_info *msblk = s->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; int i, length = 0; - struct squashfs_dir_index_2 index; + struct squashfs3_dir_index_2 index; TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %d\n", i_count, (unsigned int) f_pos); @@ -406,14 +406,14 @@ static int get_dir_index_using_offset(struct super_block *s, long long for (i = 0; i < i_count; i++) { if (msblk->swap) { - struct squashfs_dir_index_2 sindex; - squashfs_get_cached_block(s, (char *) &sindex, + struct squashfs3_dir_index_2 sindex; + squashfs3_get_cached_block(s, (char *) &sindex, index_start, index_offset, sizeof(sindex), &index_start, &index_offset); - SQUASHFS_SWAP_DIR_INDEX_2(&index, &sindex); + SQUASHFS3_SWAP_DIR_INDEX_2(&index, &sindex); } else - squashfs_get_cached_block(s, (char *) &index, + squashfs3_get_cached_block(s, (char *) &index, index_start, index_offset, sizeof(index), &index_start, &index_offset); @@ -421,7 +421,7 @@ static int get_dir_index_using_offset(struct super_block *s, long long if (index.index > f_pos) break; - squashfs_get_cached_block(s, NULL, index_start, index_offset, + squashfs3_get_cached_block(s, NULL, index_start, index_offset, index.size + 1, &index_start, &index_offset); @@ -429,7 +429,7 @@ static int get_dir_index_using_offset(struct super_block *s, long long *next_block = index.start_block + sblk->directory_table_start; } - *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE; + *next_offset = (length + *next_offset) % SQUASHFS3_METADATA_SIZE; finish: return length; @@ -442,39 +442,39 @@ static int get_dir_index_using_name(struct super_block *s, long long unsigned int index_offset, int i_count, const char *name, int size) { - struct squashfs_sb_info *msblk = s->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_sb_info *msblk = s->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; int i, length = 0; - struct squashfs_dir_index_2 *index; + struct squashfs3_dir_index_2 *index; char *str; TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count); - if (!(str = kmalloc(sizeof(struct squashfs_dir_index) + - (SQUASHFS_NAME_LEN + 1) * 2, GFP_KERNEL))) { - ERROR("Failed to allocate squashfs_dir_index\n"); + if (!(str = kmalloc(sizeof(struct squashfs3_dir_index) + + (SQUASHFS3_NAME_LEN + 1) * 2, GFP_KERNEL))) { + ERROR("Failed to allocate squashfs3_dir_index\n"); goto failure; } - index = (struct squashfs_dir_index_2 *) (str + SQUASHFS_NAME_LEN + 1); + index = (struct squashfs3_dir_index_2 *) (str + SQUASHFS3_NAME_LEN + 1); strncpy(str, name, size); str[size] = '\0'; for (i = 0; i < i_count; i++) { if (msblk->swap) { - struct squashfs_dir_index_2 sindex; - squashfs_get_cached_block(s, (char *) &sindex, + struct squashfs3_dir_index_2 sindex; + squashfs3_get_cached_block(s, (char *) &sindex, index_start, index_offset, sizeof(sindex), &index_start, &index_offset); - SQUASHFS_SWAP_DIR_INDEX_2(index, &sindex); + SQUASHFS3_SWAP_DIR_INDEX_2(index, &sindex); } else - squashfs_get_cached_block(s, (char *) index, + squashfs3_get_cached_block(s, (char *) index, index_start, index_offset, - sizeof(struct squashfs_dir_index_2), + sizeof(struct squashfs3_dir_index_2), &index_start, &index_offset); - squashfs_get_cached_block(s, index->name, index_start, + squashfs3_get_cached_block(s, index->name, index_start, index_offset, index->size + 1, &index_start, &index_offset); @@ -487,7 +487,7 @@ static int get_dir_index_using_name(struct super_block *s, long long *next_block = index->start_block + sblk->directory_table_start; } - *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE; + *next_offset = (length + *next_offset) % SQUASHFS3_METADATA_SIZE; kfree(str); failure: return length; @@ -497,43 +497,43 @@ failure: static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir) { struct inode *i = file->f_dentry->d_inode; - struct squashfs_sb_info *msblk = i->i_sb->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; - long long next_block = SQUASHFS_I(i)->start_block + + struct squashfs3_sb_info *msblk = i->i_sb->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; + long long next_block = SQUASHFS3_I(i)->start_block + sblk->directory_table_start; - int next_offset = SQUASHFS_I(i)->offset, length = 0, + int next_offset = SQUASHFS3_I(i)->offset, length = 0, dir_count; - struct squashfs_dir_header_2 dirh; - struct squashfs_dir_entry_2 *dire; + struct squashfs3_dir_header_2 dirh; + struct squashfs3_dir_entry_2 *dire; TRACE("Entered squashfs_readdir_2 [%llx:%x]\n", next_block, next_offset); - if (!(dire = kmalloc(sizeof(struct squashfs_dir_entry) + - SQUASHFS_NAME_LEN + 1, GFP_KERNEL))) { - ERROR("Failed to allocate squashfs_dir_entry\n"); + if (!(dire = kmalloc(sizeof(struct squashfs3_dir_entry) + + SQUASHFS3_NAME_LEN + 1, GFP_KERNEL))) { + ERROR("Failed to allocate squashfs3_dir_entry\n"); goto finish; } length = get_dir_index_using_offset(i->i_sb, &next_block, &next_offset, - SQUASHFS_I(i)->u.s2.directory_index_start, - SQUASHFS_I(i)->u.s2.directory_index_offset, - SQUASHFS_I(i)->u.s2.directory_index_count, + SQUASHFS3_I(i)->u.s2.directory_index_start, + SQUASHFS3_I(i)->u.s2.directory_index_offset, + SQUASHFS3_I(i)->u.s2.directory_index_count, file->f_pos); while (length < i_size_read(i)) { /* read directory header */ if (msblk->swap) { - struct squashfs_dir_header_2 sdirh; + struct squashfs3_dir_header_2 sdirh; - if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh, + if (!squashfs3_get_cached_block(i->i_sb, (char *) &sdirh, next_block, next_offset, sizeof(sdirh), &next_block, &next_offset)) goto failed_read; length += sizeof(sdirh); - SQUASHFS_SWAP_DIR_HEADER_2(&dirh, &sdirh); + SQUASHFS3_SWAP_DIR_HEADER_2(&dirh, &sdirh); } else { - if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh, + if (!squashfs3_get_cached_block(i->i_sb, (char *) &dirh, next_block, next_offset, sizeof(dirh), &next_block, &next_offset)) goto failed_read; @@ -544,17 +544,17 @@ static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir dir_count = dirh.count + 1; while (dir_count--) { if (msblk->swap) { - struct squashfs_dir_entry_2 sdire; - if (!squashfs_get_cached_block(i->i_sb, (char *) + struct squashfs3_dir_entry_2 sdire; + if (!squashfs3_get_cached_block(i->i_sb, (char *) &sdire, next_block, next_offset, sizeof(sdire), &next_block, &next_offset)) goto failed_read; length += sizeof(sdire); - SQUASHFS_SWAP_DIR_ENTRY_2(dire, &sdire); + SQUASHFS3_SWAP_DIR_ENTRY_2(dire, &sdire); } else { - if (!squashfs_get_cached_block(i->i_sb, (char *) + if (!squashfs3_get_cached_block(i->i_sb, (char *) dire, next_block, next_offset, sizeof(*dire), &next_block, &next_offset)) @@ -563,7 +563,7 @@ static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir length += sizeof(*dire); } - if (!squashfs_get_cached_block(i->i_sb, dire->name, + if (!squashfs3_get_cached_block(i->i_sb, dire->name, next_block, next_offset, dire->size + 1, &next_block, &next_offset)) @@ -583,7 +583,7 @@ static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir squashfs_filetype_table[dire->type]); if (filldir(dirent, dire->name, dire->size + 1, - file->f_pos, SQUASHFS_MK_VFS_INODE( + file->f_pos, SQUASHFS3_MK_VFS_INODE( dirh.start_block, dire->offset), squashfs_filetype_table[dire->type]) < 0) { @@ -612,46 +612,46 @@ static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry, const unsigned char *name = dentry->d_name.name; int len = dentry->d_name.len; struct inode *inode = NULL; - struct squashfs_sb_info *msblk = i->i_sb->s_fs_info; - struct squashfs_super_block *sblk = &msblk->sblk; - long long next_block = SQUASHFS_I(i)->start_block + + struct squashfs3_sb_info *msblk = i->i_sb->s_fs_info; + struct squashfs3_super_block *sblk = &msblk->sblk; + long long next_block = SQUASHFS3_I(i)->start_block + sblk->directory_table_start; - int next_offset = SQUASHFS_I(i)->offset, length = 0, + int next_offset = SQUASHFS3_I(i)->offset, length = 0, dir_count; - struct squashfs_dir_header_2 dirh; - struct squashfs_dir_entry_2 *dire; + struct squashfs3_dir_header_2 dirh; + struct squashfs3_dir_entry_2 *dire; int sorted = sblk->s_major == 2 && sblk->s_minor >= 1; TRACE("Entered squashfs_lookup_2 [%llx:%x]\n", next_block, next_offset); - if (!(dire = kmalloc(sizeof(struct squashfs_dir_entry) + - SQUASHFS_NAME_LEN + 1, GFP_KERNEL))) { - ERROR("Failed to allocate squashfs_dir_entry\n"); + if (!(dire = kmalloc(sizeof(struct squashfs3_dir_entry) + + SQUASHFS3_NAME_LEN + 1, GFP_KERNEL))) { + ERROR("Failed to allocate squashfs3_dir_entry\n"); goto exit_loop; } - if (len > SQUASHFS_NAME_LEN) + if (len > SQUASHFS3_NAME_LEN) goto exit_loop; length = get_dir_index_using_name(i->i_sb, &next_block, &next_offset, - SQUASHFS_I(i)->u.s2.directory_index_start, - SQUASHFS_I(i)->u.s2.directory_index_offset, - SQUASHFS_I(i)->u.s2.directory_index_count, name, + SQUASHFS3_I(i)->u.s2.directory_index_start, + SQUASHFS3_I(i)->u.s2.directory_index_offset, + SQUASHFS3_I(i)->u.s2.directory_index_count, name, len); while (length < i_size_read(i)) { /* read directory header */ if (msblk->swap) { - struct squashfs_dir_header_2 sdirh; - if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh, + struct squashfs3_dir_header_2 sdirh; + if (!squashfs3_get_cached_block(i->i_sb, (char *) &sdirh, next_block, next_offset, sizeof(sdirh), &next_block, &next_offset)) goto failed_read; length += sizeof(sdirh); - SQUASHFS_SWAP_DIR_HEADER_2(&dirh, &sdirh); + SQUASHFS3_SWAP_DIR_HEADER_2(&dirh, &sdirh); } else { - if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh, + if (!squashfs3_get_cached_block(i->i_sb, (char *) &dirh, next_block, next_offset, sizeof(dirh), &next_block, &next_offset)) goto failed_read; @@ -662,17 +662,17 @@ static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry, dir_count = dirh.count + 1; while (dir_count--) { if (msblk->swap) { - struct squashfs_dir_entry_2 sdire; - if (!squashfs_get_cached_block(i->i_sb, (char *) + struct squashfs3_dir_entry_2 sdire; + if (!squashfs3_get_cached_block(i->i_sb, (char *) &sdire, next_block,next_offset, sizeof(sdire), &next_block, &next_offset)) goto failed_read; length += sizeof(sdire); - SQUASHFS_SWAP_DIR_ENTRY_2(dire, &sdire); + SQUASHFS3_SWAP_DIR_ENTRY_2(dire, &sdire); } else { - if (!squashfs_get_cached_block(i->i_sb, (char *) + if (!squashfs3_get_cached_block(i->i_sb, (char *) dire, next_block,next_offset, sizeof(*dire), &next_block, &next_offset)) @@ -681,7 +681,7 @@ static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry, length += sizeof(*dire); } - if (!squashfs_get_cached_block(i->i_sb, dire->name, + if (!squashfs3_get_cached_block(i->i_sb, dire->name, next_block, next_offset, dire->size + 1, &next_block, &next_offset)) goto failed_read; @@ -693,17 +693,17 @@ static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry, if ((len == dire->size + 1) && !strncmp(name, dire->name, len)) { - squashfs_inode_t ino = - SQUASHFS_MKINODE(dirh.start_block, + squashfs3_inode_t ino = + SQUASHFS3_MKINODE(dirh.start_block, dire->offset); - unsigned int inode_number = SQUASHFS_MK_VFS_INODE(dirh.start_block, + unsigned int inode_number = SQUASHFS3_MK_VFS_INODE(dirh.start_block, dire->offset); - TRACE("calling squashfs_iget for directory " + TRACE("calling squashfs3_iget for directory " "entry %s, inode %x:%x, %lld\n", name, dirh.start_block, dire->offset, ino); - inode = squashfs_iget(i->i_sb, ino, inode_number); + inode = squashfs3_iget(i->i_sb, ino, inode_number); goto exit_loop; } @@ -722,9 +722,9 @@ failed_read: } -int squashfs_2_0_supported(struct squashfs_sb_info *msblk) +int squashfs3_2_0_supported(struct squashfs3_sb_info *msblk) { - struct squashfs_super_block *sblk = &msblk->sblk; + struct squashfs3_super_block *sblk = &msblk->sblk; msblk->read_inode = squashfs_read_inode_2; msblk->read_fragment_index_table = read_fragment_index_table_2; diff --git a/fs/squashfs3/squashfs3.h b/fs/squashfs3/squashfs3.h index 4e11742..28a13e7 100644 --- a/fs/squashfs3/squashfs3.h +++ b/fs/squashfs3/squashfs3.h @@ -21,11 +21,11 @@ * squashfs.h */ -#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY -#undef CONFIG_SQUASHFS_1_0_COMPATIBILITY +#ifdef CONFIG_SQUASHFS3_1_0_COMPATIBILITY +#undef CONFIG_SQUASHFS3_1_0_COMPATIBILITY #endif -#ifdef SQUASHFS_TRACE +#ifdef SQUASHFS3_TRACE #define TRACE(s, args...) printk(KERN_NOTICE "SQUASHFS: "s, ## args) #else #define TRACE(s, args...) {} @@ -40,46 +40,46 @@ #define WARNING(s, args...) printk(KERN_WARNING "SQUASHFS: "s, ## args) -static inline struct squashfs_inode_info *SQUASHFS_I(struct inode *inode) +static inline struct squashfs3_inode_info *SQUASHFS3_I(struct inode *inode) { - return list_entry(inode, struct squashfs_inode_info, vfs_inode); + return list_entry(inode, struct squashfs3_inode_info, vfs_inode); } -#if defined(CONFIG_SQUASHFS_1_0_COMPATIBILITY ) || defined(CONFIG_SQUASHFS_2_0_COMPATIBILITY) +#if defined(CONFIG_SQUASHFS3_1_0_COMPATIBILITY ) || defined(CONFIG_SQUASHFS3_2_0_COMPATIBILITY) #define SQSH_EXTERN -extern unsigned int squashfs_read_data(struct super_block *s, char *buffer, +extern unsigned int squashfs3_read_data(struct super_block *s, char *buffer, long long index, unsigned int length, long long *next_index, int srclength); -extern int squashfs_get_cached_block(struct super_block *s, void *buffer, +extern int squashfs3_get_cached_block(struct super_block *s, void *buffer, long long block, unsigned int offset, int length, long long *next_block, unsigned int *next_offset); -extern void release_cached_fragment(struct squashfs_sb_info *msblk, struct - squashfs_cache_entry *fragment); -extern struct squashfs_cache_entry *get_cached_fragment(struct super_block +extern void release_cached_fragment(struct squashfs3_sb_info *msblk, struct + squashfs3_cache_entry *fragment); +extern struct squashfs3_cache_entry *get_cached_fragment(struct super_block *s, long long start_block, int length); -extern struct inode *squashfs_iget(struct super_block *s, squashfs_inode_t inode, unsigned int inode_number); -extern const struct address_space_operations squashfs_symlink_aops; -extern const struct address_space_operations squashfs_aops; -extern struct inode_operations squashfs_dir_inode_ops; +extern struct inode *squashfs3_iget(struct super_block *s, squashfs3_inode_t inode, unsigned int inode_number); +extern const struct address_space_operations squashfs3_symlink_aops; +extern const struct address_space_operations squashfs3_aops; +extern struct inode_operations squashfs3_dir_inode_ops; #else #define SQSH_EXTERN static #endif -#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY -extern int squashfs_1_0_supported(struct squashfs_sb_info *msblk); +#ifdef CONFIG_SQUASHFS3_1_0_COMPATIBILITY +extern int squashfs3_1_0_supported(struct squashfs3_sb_info *msblk); #else -static inline int squashfs_1_0_supported(struct squashfs_sb_info *msblk) +static inline int squashfs3_1_0_supported(struct squashfs3_sb_info *msblk) { return 0; } #endif -#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY -extern int squashfs_2_0_supported(struct squashfs_sb_info *msblk); +#ifdef CONFIG_SQUASHFS3_2_0_COMPATIBILITY +extern int squashfs3_2_0_supported(struct squashfs3_sb_info *msblk); #else -static inline int squashfs_2_0_supported(struct squashfs_sb_info *msblk) +static inline int squashfs3_2_0_supported(struct squashfs3_sb_info *msblk) { return 0; } diff --git a/include/linux/squashfs3_fs.h b/include/linux/squashfs3_fs.h index 7882a64..a97297e 100644 --- a/include/linux/squashfs3_fs.h +++ b/include/linux/squashfs3_fs.h @@ -1,5 +1,5 @@ -#ifndef SQUASHFS_FS -#define SQUASHFS_FS +#ifndef SQUASHFS3_FS +#define SQUASHFS3_FS /* * Squashfs @@ -24,177 +24,177 @@ * squashfs3_fs.h */ -#ifndef CONFIG_SQUASHFS_2_0_COMPATIBILITY -#define CONFIG_SQUASHFS_2_0_COMPATIBILITY +#ifndef CONFIG_SQUASHFS3_2_0_COMPATIBILITY +#define CONFIG_SQUASHFS3_2_0_COMPATIBILITY #endif -#define SQUASHFS_CACHED_FRAGMENTS CONFIG_SQUASHFS3_FRAGMENT_CACHE_SIZE -#define SQUASHFS_MAJOR 3 -#define SQUASHFS_MINOR 1 -#define SQUASHFS_MAGIC 0x73717368 -#define SQUASHFS_MAGIC_SWAP 0x68737173 -#define SQUASHFS_START 0 +#define SQUASHFS3_CACHED_FRAGMENTS CONFIG_SQUASHFS3_FRAGMENT_CACHE_SIZE +#define SQUASHFS3_MAJOR 3 +#define SQUASHFS3_MINOR 1 +#define SQUASHFS3_MAGIC 0x73717368 +#define SQUASHFS3_MAGIC_SWAP 0x68737173 +#define SQUASHFS3_START 0 /* size of metadata (inode and directory) blocks */ -#define SQUASHFS_METADATA_SIZE 8192 -#define SQUASHFS_METADATA_LOG 13 +#define SQUASHFS3_METADATA_SIZE 8192 +#define SQUASHFS3_METADATA_LOG 13 /* default size of data blocks */ -#define SQUASHFS_FILE_SIZE 131072 -#define SQUASHFS_FILE_LOG 17 +#define SQUASHFS3_FILE_SIZE 131072 +#define SQUASHFS3_FILE_LOG 17 -#define SQUASHFS_FILE_MAX_SIZE 1048576 +#define SQUASHFS3_FILE_MAX_SIZE 1048576 /* Max number of uids and gids */ -#define SQUASHFS_UIDS 256 -#define SQUASHFS_GUIDS 255 +#define SQUASHFS3_UIDS 256 +#define SQUASHFS3_GUIDS 255 /* Max length of filename (not 255) */ -#define SQUASHFS_NAME_LEN 256 +#define SQUASHFS3_NAME_LEN 256 -#define SQUASHFS_INVALID ((long long) 0xffffffffffff) -#define SQUASHFS_INVALID_FRAG ((unsigned int) 0xffffffff) -#define SQUASHFS_INVALID_BLK ((long long) -1) -#define SQUASHFS_USED_BLK ((long long) -2) +#define SQUASHFS3_INVALID ((long long) 0xffffffffffff) +#define SQUASHFS3_INVALID_FRAG ((unsigned int) 0xffffffff) +#define SQUASHFS3_INVALID_BLK ((long long) -1) +#define SQUASHFS3_USED_BLK ((long long) -2) /* Filesystem flags */ -#define SQUASHFS_NOI 0 -#define SQUASHFS_NOD 1 -#define SQUASHFS_CHECK 2 -#define SQUASHFS_NOF 3 -#define SQUASHFS_NO_FRAG 4 -#define SQUASHFS_ALWAYS_FRAG 5 -#define SQUASHFS_DUPLICATE 6 -#define SQUASHFS_EXPORT 7 +#define SQUASHFS3_NOI 0 +#define SQUASHFS3_NOD 1 +#define SQUASHFS3_CHECK 2 +#define SQUASHFS3_NOF 3 +#define SQUASHFS3_NO_FRAG 4 +#define SQUASHFS3_ALWAYS_FRAG 5 +#define SQUASHFS3_DUPLICATE 6 +#define SQUASHFS3_EXPORT 7 -#define SQUASHFS_BIT(flag, bit) ((flag >> bit) & 1) +#define SQUASHFS3_BIT(flag, bit) ((flag >> bit) & 1) -#define SQUASHFS_UNCOMPRESSED_INODES(flags) SQUASHFS_BIT(flags, \ - SQUASHFS_NOI) +#define SQUASHFS3_UNCOMPRESSED_INODES(flags) SQUASHFS3_BIT(flags, \ + SQUASHFS3_NOI) -#define SQUASHFS_UNCOMPRESSED_DATA(flags) SQUASHFS_BIT(flags, \ - SQUASHFS_NOD) +#define SQUASHFS3_UNCOMPRESSED_DATA(flags) SQUASHFS3_BIT(flags, \ + SQUASHFS3_NOD) -#define SQUASHFS_UNCOMPRESSED_FRAGMENTS(flags) SQUASHFS_BIT(flags, \ - SQUASHFS_NOF) +#define SQUASHFS3_UNCOMPRESSED_FRAGMENTS(flags) SQUASHFS3_BIT(flags, \ + SQUASHFS3_NOF) -#define SQUASHFS_NO_FRAGMENTS(flags) SQUASHFS_BIT(flags, \ - SQUASHFS_NO_FRAG) +#define SQUASHFS3_NO_FRAGMENTS(flags) SQUASHFS3_BIT(flags, \ + SQUASHFS3_NO_FRAG) -#define SQUASHFS_ALWAYS_FRAGMENTS(flags) SQUASHFS_BIT(flags, \ - SQUASHFS_ALWAYS_FRAG) +#define SQUASHFS3_ALWAYS_FRAGMENTS(flags) SQUASHFS3_BIT(flags, \ + SQUASHFS3_ALWAYS_FRAG) -#define SQUASHFS_DUPLICATES(flags) SQUASHFS_BIT(flags, \ - SQUASHFS_DUPLICATE) +#define SQUASHFS3_DUPLICATES(flags) SQUASHFS3_BIT(flags, \ + SQUASHFS3_DUPLICATE) -#define SQUASHFS_EXPORTABLE(flags) SQUASHFS_BIT(flags, \ - SQUASHFS_EXPORT) +#define SQUASHFS3_EXPORTABLE(flags) SQUASHFS3_BIT(flags, \ + SQUASHFS3_EXPORT) -#define SQUASHFS_CHECK_DATA(flags) SQUASHFS_BIT(flags, \ - SQUASHFS_CHECK) +#define SQUASHFS3_CHECK_DATA(flags) SQUASHFS3_BIT(flags, \ + SQUASHFS3_CHECK) -#define SQUASHFS_MKFLAGS(noi, nod, check_data, nof, no_frag, always_frag, \ +#define SQUASHFS3_MKFLAGS(noi, nod, check_data, nof, no_frag, always_frag, \ duplicate_checking, exportable) (noi | (nod << 1) | (check_data << 2) \ | (nof << 3) | (no_frag << 4) | (always_frag << 5) | \ (duplicate_checking << 6) | (exportable << 7)) /* Max number of types and file types */ -#define SQUASHFS_DIR_TYPE 1 -#define SQUASHFS_FILE_TYPE 2 -#define SQUASHFS_SYMLINK_TYPE 3 -#define SQUASHFS_BLKDEV_TYPE 4 -#define SQUASHFS_CHRDEV_TYPE 5 -#define SQUASHFS_FIFO_TYPE 6 -#define SQUASHFS_SOCKET_TYPE 7 -#define SQUASHFS_LDIR_TYPE 8 -#define SQUASHFS_LREG_TYPE 9 +#define SQUASHFS3_DIR_TYPE 1 +#define SQUASHFS3_FILE_TYPE 2 +#define SQUASHFS3_SYMLINK_TYPE 3 +#define SQUASHFS3_BLKDEV_TYPE 4 +#define SQUASHFS3_CHRDEV_TYPE 5 +#define SQUASHFS3_FIFO_TYPE 6 +#define SQUASHFS3_SOCKET_TYPE 7 +#define SQUASHFS3_LDIR_TYPE 8 +#define SQUASHFS3_LREG_TYPE 9 /* 1.0 filesystem type definitions */ -#define SQUASHFS_TYPES 5 -#define SQUASHFS_IPC_TYPE 0 +#define SQUASHFS3_TYPES 5 +#define SQUASHFS3_IPC_TYPE 0 /* Flag whether block is compressed or uncompressed, bit is set if block is * uncompressed */ -#define SQUASHFS_COMPRESSED_BIT (1 << 15) +#define SQUASHFS3_COMPRESSED_BIT (1 << 15) -#define SQUASHFS_COMPRESSED_SIZE(B) (((B) & ~SQUASHFS_COMPRESSED_BIT) ? \ - (B) & ~SQUASHFS_COMPRESSED_BIT : SQUASHFS_COMPRESSED_BIT) +#define SQUASHFS3_COMPRESSED_SIZE(B) (((B) & ~SQUASHFS3_COMPRESSED_BIT) ? \ + (B) & ~SQUASHFS3_COMPRESSED_BIT : SQUASHFS3_COMPRESSED_BIT) -#define SQUASHFS_COMPRESSED(B) (!((B) & SQUASHFS_COMPRESSED_BIT)) +#define SQUASHFS3_COMPRESSED(B) (!((B) & SQUASHFS3_COMPRESSED_BIT)) -#define SQUASHFS_COMPRESSED_BIT_BLOCK (1 << 24) +#define SQUASHFS3_COMPRESSED_BIT_BLOCK (1 << 24) -#define SQUASHFS_COMPRESSED_SIZE_BLOCK(B) ((B) & \ - ~SQUASHFS_COMPRESSED_BIT_BLOCK) +#define SQUASHFS3_COMPRESSED_SIZE_BLOCK(B) ((B) & \ + ~SQUASHFS3_COMPRESSED_BIT_BLOCK) -#define SQUASHFS_COMPRESSED_BLOCK(B) (!((B) & SQUASHFS_COMPRESSED_BIT_BLOCK)) +#define SQUASHFS3_COMPRESSED_BLOCK(B) (!((B) & SQUASHFS3_COMPRESSED_BIT_BLOCK)) /* * Inode number ops. Inodes consist of a compressed block number, and an * uncompressed offset within that block */ -#define SQUASHFS_INODE_BLK(a) ((unsigned int) ((a) >> 16)) +#define SQUASHFS3_INODE_BLK(a) ((unsigned int) ((a) >> 16)) -#define SQUASHFS_INODE_OFFSET(a) ((unsigned int) ((a) & 0xffff)) +#define SQUASHFS3_INODE_OFFSET(a) ((unsigned int) ((a) & 0xffff)) -#define SQUASHFS_MKINODE(A, B) ((squashfs_inode_t)(((squashfs_inode_t) (A)\ +#define SQUASHFS3_MKINODE(A, B) ((squashfs3_inode_t)(((squashfs3_inode_t) (A)\ << 16) + (B))) /* Compute 32 bit VFS inode number from squashfs inode number */ -#define SQUASHFS_MK_VFS_INODE(a, b) ((unsigned int) (((a) << 8) + \ +#define SQUASHFS3_MK_VFS_INODE(a, b) ((unsigned int) (((a) << 8) + \ ((b) >> 2) + 1)) /* XXX */ /* Translate between VFS mode and squashfs mode */ -#define SQUASHFS_MODE(a) ((a) & 0xfff) +#define SQUASHFS3_MODE(a) ((a) & 0xfff) /* fragment and fragment table defines */ -#define SQUASHFS_FRAGMENT_BYTES(A) ((A) * sizeof(struct squashfs_fragment_entry)) +#define SQUASHFS3_FRAGMENT_BYTES(A) ((A) * sizeof(struct squashfs3_fragment_entry)) -#define SQUASHFS_FRAGMENT_INDEX(A) (SQUASHFS_FRAGMENT_BYTES(A) / \ - SQUASHFS_METADATA_SIZE) +#define SQUASHFS3_FRAGMENT_INDEX(A) (SQUASHFS3_FRAGMENT_BYTES(A) / \ + SQUASHFS3_METADATA_SIZE) -#define SQUASHFS_FRAGMENT_INDEX_OFFSET(A) (SQUASHFS_FRAGMENT_BYTES(A) % \ - SQUASHFS_METADATA_SIZE) +#define SQUASHFS3_FRAGMENT_INDEX_OFFSET(A) (SQUASHFS3_FRAGMENT_BYTES(A) % \ + SQUASHFS3_METADATA_SIZE) -#define SQUASHFS_FRAGMENT_INDEXES(A) ((SQUASHFS_FRAGMENT_BYTES(A) + \ - SQUASHFS_METADATA_SIZE - 1) / \ - SQUASHFS_METADATA_SIZE) +#define SQUASHFS3_FRAGMENT_INDEXES(A) ((SQUASHFS3_FRAGMENT_BYTES(A) + \ + SQUASHFS3_METADATA_SIZE - 1) / \ + SQUASHFS3_METADATA_SIZE) -#define SQUASHFS_FRAGMENT_INDEX_BYTES(A) (SQUASHFS_FRAGMENT_INDEXES(A) *\ +#define SQUASHFS3_FRAGMENT_INDEX_BYTES(A) (SQUASHFS3_FRAGMENT_INDEXES(A) *\ sizeof(long long)) /* inode lookup table defines */ -#define SQUASHFS_LOOKUP_BYTES(A) ((A) * sizeof(squashfs_inode_t)) +#define SQUASHFS3_LOOKUP_BYTES(A) ((A) * sizeof(squashfs3_inode_t)) -#define SQUASHFS_LOOKUP_BLOCK(A) (SQUASHFS_LOOKUP_BYTES(A) / \ - SQUASHFS_METADATA_SIZE) +#define SQUASHFS3_LOOKUP_BLOCK(A) (SQUASHFS3_LOOKUP_BYTES(A) / \ + SQUASHFS3_METADATA_SIZE) -#define SQUASHFS_LOOKUP_BLOCK_OFFSET(A) (SQUASHFS_LOOKUP_BYTES(A) % \ - SQUASHFS_METADATA_SIZE) +#define SQUASHFS3_LOOKUP_BLOCK_OFFSET(A) (SQUASHFS3_LOOKUP_BYTES(A) % \ + SQUASHFS3_METADATA_SIZE) -#define SQUASHFS_LOOKUP_BLOCKS(A) ((SQUASHFS_LOOKUP_BYTES(A) + \ - SQUASHFS_METADATA_SIZE - 1) / \ - SQUASHFS_METADATA_SIZE) +#define SQUASHFS3_LOOKUP_BLOCKS(A) ((SQUASHFS3_LOOKUP_BYTES(A) + \ + SQUASHFS3_METADATA_SIZE - 1) / \ + SQUASHFS3_METADATA_SIZE) -#define SQUASHFS_LOOKUP_BLOCK_BYTES(A) (SQUASHFS_LOOKUP_BLOCKS(A) *\ +#define SQUASHFS3_LOOKUP_BLOCK_BYTES(A) (SQUASHFS3_LOOKUP_BLOCKS(A) *\ sizeof(long long)) /* cached data constants for filesystem */ -#define SQUASHFS_CACHED_BLKS 8 +#define SQUASHFS3_CACHED_BLKS 8 -#define SQUASHFS_MAX_FILE_SIZE_LOG 64 +#define SQUASHFS3_MAX_FILE_SIZE_LOG 64 -#define SQUASHFS_MAX_FILE_SIZE ((long long) 1 << \ - (SQUASHFS_MAX_FILE_SIZE_LOG - 2)) +#define SQUASHFS3_MAX_FILE_SIZE ((long long) 1 << \ + (SQUASHFS3_MAX_FILE_SIZE_LOG - 2)) -#define SQUASHFS_MARKER_BYTE 0xff +#define SQUASHFS3_MARKER_BYTE 0xff /* meta index cache */ -#define SQUASHFS_META_INDEXES (SQUASHFS_METADATA_SIZE / sizeof(unsigned int)) -#define SQUASHFS_META_ENTRIES 31 -#define SQUASHFS_META_NUMBER 8 -#define SQUASHFS_SLOTS 4 +#define SQUASHFS3_META_INDEXES (SQUASHFS3_METADATA_SIZE / sizeof(unsigned int)) +#define SQUASHFS3_META_ENTRIES 31 +#define SQUASHFS3_META_NUMBER 8 +#define SQUASHFS3_SLOTS 4 struct meta_entry { long long data_block; @@ -210,7 +210,7 @@ struct meta_index { unsigned short skip; unsigned short locked; unsigned short pad; - struct meta_entry meta_entry[SQUASHFS_META_ENTRIES]; + struct meta_entry meta_entry[SQUASHFS3_META_ENTRIES]; }; @@ -218,10 +218,10 @@ struct meta_index { * definitions for structures on disk */ -typedef long long squashfs_block_t; -typedef long long squashfs_inode_t; +typedef long long squashfs3_block_t; +typedef long long squashfs3_inode_t; -struct squashfs_super_block { +struct squashfs3_super_block { unsigned int s_magic; unsigned int inodes; unsigned int bytes_used_2; @@ -237,7 +237,7 @@ struct squashfs_super_block { unsigned int no_uids:8; unsigned int no_guids:8; unsigned int mkfs_time /* time of filesystem creation */; - squashfs_inode_t root_inode; + squashfs3_inode_t root_inode; unsigned int block_size; unsigned int fragments; unsigned int fragment_table_start_2; @@ -250,14 +250,14 @@ struct squashfs_super_block { long long lookup_table_start; } __attribute__ ((packed)); -struct squashfs_dir_index { +struct squashfs3_dir_index { unsigned int index; unsigned int start_block; unsigned char size; unsigned char name[0]; } __attribute__ ((packed)); -#define SQUASHFS_BASE_INODE_HEADER \ +#define SQUASHFS3_BASE_INODE_HEADER \ unsigned int inode_type:4; \ unsigned int mode:12; \ unsigned int uid:8; \ @@ -265,49 +265,49 @@ struct squashfs_dir_index { unsigned int mtime; \ unsigned int inode_number; -struct squashfs_base_inode_header { - SQUASHFS_BASE_INODE_HEADER; +struct squashfs3_base_inode_header { + SQUASHFS3_BASE_INODE_HEADER; } __attribute__ ((packed)); -struct squashfs_ipc_inode_header { - SQUASHFS_BASE_INODE_HEADER; +struct squashfs3_ipc_inode_header { + SQUASHFS3_BASE_INODE_HEADER; unsigned int nlink; } __attribute__ ((packed)); -struct squashfs_dev_inode_header { - SQUASHFS_BASE_INODE_HEADER; +struct squashfs3_dev_inode_header { + SQUASHFS3_BASE_INODE_HEADER; unsigned int nlink; unsigned short rdev; } __attribute__ ((packed)); -struct squashfs_symlink_inode_header { - SQUASHFS_BASE_INODE_HEADER; +struct squashfs3_symlink_inode_header { + SQUASHFS3_BASE_INODE_HEADER; unsigned int nlink; unsigned short symlink_size; char symlink[0]; } __attribute__ ((packed)); -struct squashfs_reg_inode_header { - SQUASHFS_BASE_INODE_HEADER; - squashfs_block_t start_block; +struct squashfs3_reg_inode_header { + SQUASHFS3_BASE_INODE_HEADER; + squashfs3_block_t start_block; unsigned int fragment; unsigned int offset; unsigned int file_size; unsigned short block_list[0]; } __attribute__ ((packed)); -struct squashfs_lreg_inode_header { - SQUASHFS_BASE_INODE_HEADER; +struct squashfs3_lreg_inode_header { + SQUASHFS3_BASE_INODE_HEADER; unsigned int nlink; - squashfs_block_t start_block; + squashfs3_block_t start_block; unsigned int fragment; unsigned int offset; long long file_size; unsigned short block_list[0]; } __attribute__ ((packed)); -struct squashfs_dir_inode_header { - SQUASHFS_BASE_INODE_HEADER; +struct squashfs3_dir_inode_header { + SQUASHFS3_BASE_INODE_HEADER; unsigned int nlink; unsigned int file_size:19; unsigned int offset:13; @@ -315,29 +315,29 @@ struct squashfs_dir_inode_header { unsigned int parent_inode; } __attribute__ ((packed)); -struct squashfs_ldir_inode_header { - SQUASHFS_BASE_INODE_HEADER; +struct squashfs3_ldir_inode_header { + SQUASHFS3_BASE_INODE_HEADER; unsigned int nlink; unsigned int file_size:27; unsigned int offset:13; unsigned int start_block; unsigned int i_count:16; unsigned int parent_inode; - struct squashfs_dir_index index[0]; + struct squashfs3_dir_index index[0]; } __attribute__ ((packed)); -union squashfs_inode_header { - struct squashfs_base_inode_header base; - struct squashfs_dev_inode_header dev; - struct squashfs_symlink_inode_header symlink; - struct squashfs_reg_inode_header reg; - struct squashfs_lreg_inode_header lreg; - struct squashfs_dir_inode_header dir; - struct squashfs_ldir_inode_header ldir; - struct squashfs_ipc_inode_header ipc; +union squashfs3_inode_header { + struct squashfs3_base_inode_header base; + struct squashfs3_dev_inode_header dev; + struct squashfs3_symlink_inode_header symlink; + struct squashfs3_reg_inode_header reg; + struct squashfs3_lreg_inode_header lreg; + struct squashfs3_dir_inode_header dir; + struct squashfs3_ldir_inode_header ldir; + struct squashfs3_ipc_inode_header ipc; }; -struct squashfs_dir_entry { +struct squashfs3_dir_entry { unsigned int offset:13; unsigned int type:3; unsigned int size:8; @@ -345,13 +345,13 @@ struct squashfs_dir_entry { char name[0]; } __attribute__ ((packed)); -struct squashfs_dir_header { +struct squashfs3_dir_header { unsigned int count:8; unsigned int start_block; unsigned int inode_number; } __attribute__ ((packed)); -struct squashfs_fragment_entry { +struct squashfs3_fragment_entry { long long start_block; unsigned int size; unsigned int unused; @@ -368,212 +368,212 @@ extern int squashfs_uncompress_exit(void); * */ -#define SQUASHFS_SWAP_START \ +#define SQUASHFS3_SWAP_START \ int bits;\ int b_pos;\ unsigned long long val;\ unsigned char *s;\ unsigned char *d; -#define SQUASHFS_SWAP_SUPER_BLOCK(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_super_block));\ - SQUASHFS_SWAP((s)->s_magic, d, 0, 32);\ - SQUASHFS_SWAP((s)->inodes, d, 32, 32);\ - SQUASHFS_SWAP((s)->bytes_used_2, d, 64, 32);\ - SQUASHFS_SWAP((s)->uid_start_2, d, 96, 32);\ - SQUASHFS_SWAP((s)->guid_start_2, d, 128, 32);\ - SQUASHFS_SWAP((s)->inode_table_start_2, d, 160, 32);\ - SQUASHFS_SWAP((s)->directory_table_start_2, d, 192, 32);\ - SQUASHFS_SWAP((s)->s_major, d, 224, 16);\ - SQUASHFS_SWAP((s)->s_minor, d, 240, 16);\ - SQUASHFS_SWAP((s)->block_size_1, d, 256, 16);\ - SQUASHFS_SWAP((s)->block_log, d, 272, 16);\ - SQUASHFS_SWAP((s)->flags, d, 288, 8);\ - SQUASHFS_SWAP((s)->no_uids, d, 296, 8);\ - SQUASHFS_SWAP((s)->no_guids, d, 304, 8);\ - SQUASHFS_SWAP((s)->mkfs_time, d, 312, 32);\ - SQUASHFS_SWAP((s)->root_inode, d, 344, 64);\ - SQUASHFS_SWAP((s)->block_size, d, 408, 32);\ - SQUASHFS_SWAP((s)->fragments, d, 440, 32);\ - SQUASHFS_SWAP((s)->fragment_table_start_2, d, 472, 32);\ - SQUASHFS_SWAP((s)->bytes_used, d, 504, 64);\ - SQUASHFS_SWAP((s)->uid_start, d, 568, 64);\ - SQUASHFS_SWAP((s)->guid_start, d, 632, 64);\ - SQUASHFS_SWAP((s)->inode_table_start, d, 696, 64);\ - SQUASHFS_SWAP((s)->directory_table_start, d, 760, 64);\ - SQUASHFS_SWAP((s)->fragment_table_start, d, 824, 64);\ - SQUASHFS_SWAP((s)->lookup_table_start, d, 888, 64);\ -} - -#define SQUASHFS_SWAP_BASE_INODE_CORE(s, d, n)\ - SQUASHFS_MEMSET(s, d, n);\ - SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\ - SQUASHFS_SWAP((s)->mode, d, 4, 12);\ - SQUASHFS_SWAP((s)->uid, d, 16, 8);\ - SQUASHFS_SWAP((s)->guid, d, 24, 8);\ - SQUASHFS_SWAP((s)->mtime, d, 32, 32);\ - SQUASHFS_SWAP((s)->inode_number, d, 64, 32); - -#define SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, n) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE(s, d, n)\ -} - -#define SQUASHFS_SWAP_IPC_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \ - sizeof(struct squashfs_ipc_inode_header))\ - SQUASHFS_SWAP((s)->nlink, d, 96, 32);\ -} - -#define SQUASHFS_SWAP_DEV_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \ - sizeof(struct squashfs_dev_inode_header)); \ - SQUASHFS_SWAP((s)->nlink, d, 96, 32);\ - SQUASHFS_SWAP((s)->rdev, d, 128, 16);\ -} - -#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \ - sizeof(struct squashfs_symlink_inode_header));\ - SQUASHFS_SWAP((s)->nlink, d, 96, 32);\ - SQUASHFS_SWAP((s)->symlink_size, d, 128, 16);\ -} - -#define SQUASHFS_SWAP_REG_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \ - sizeof(struct squashfs_reg_inode_header));\ - SQUASHFS_SWAP((s)->start_block, d, 96, 64);\ - SQUASHFS_SWAP((s)->fragment, d, 160, 32);\ - SQUASHFS_SWAP((s)->offset, d, 192, 32);\ - SQUASHFS_SWAP((s)->file_size, d, 224, 32);\ -} - -#define SQUASHFS_SWAP_LREG_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \ - sizeof(struct squashfs_lreg_inode_header));\ - SQUASHFS_SWAP((s)->nlink, d, 96, 32);\ - SQUASHFS_SWAP((s)->start_block, d, 128, 64);\ - SQUASHFS_SWAP((s)->fragment, d, 192, 32);\ - SQUASHFS_SWAP((s)->offset, d, 224, 32);\ - SQUASHFS_SWAP((s)->file_size, d, 256, 64);\ -} - -#define SQUASHFS_SWAP_DIR_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \ - sizeof(struct squashfs_dir_inode_header));\ - SQUASHFS_SWAP((s)->nlink, d, 96, 32);\ - SQUASHFS_SWAP((s)->file_size, d, 128, 19);\ - SQUASHFS_SWAP((s)->offset, d, 147, 13);\ - SQUASHFS_SWAP((s)->start_block, d, 160, 32);\ - SQUASHFS_SWAP((s)->parent_inode, d, 192, 32);\ -} - -#define SQUASHFS_SWAP_LDIR_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \ - sizeof(struct squashfs_ldir_inode_header));\ - SQUASHFS_SWAP((s)->nlink, d, 96, 32);\ - SQUASHFS_SWAP((s)->file_size, d, 128, 27);\ - SQUASHFS_SWAP((s)->offset, d, 155, 13);\ - SQUASHFS_SWAP((s)->start_block, d, 168, 32);\ - SQUASHFS_SWAP((s)->i_count, d, 200, 16);\ - SQUASHFS_SWAP((s)->parent_inode, d, 216, 32);\ -} - -#define SQUASHFS_SWAP_DIR_INDEX(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index));\ - SQUASHFS_SWAP((s)->index, d, 0, 32);\ - SQUASHFS_SWAP((s)->start_block, d, 32, 32);\ - SQUASHFS_SWAP((s)->size, d, 64, 8);\ -} - -#define SQUASHFS_SWAP_DIR_HEADER(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header));\ - SQUASHFS_SWAP((s)->count, d, 0, 8);\ - SQUASHFS_SWAP((s)->start_block, d, 8, 32);\ - SQUASHFS_SWAP((s)->inode_number, d, 40, 32);\ -} - -#define SQUASHFS_SWAP_DIR_ENTRY(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry));\ - SQUASHFS_SWAP((s)->offset, d, 0, 13);\ - SQUASHFS_SWAP((s)->type, d, 13, 3);\ - SQUASHFS_SWAP((s)->size, d, 16, 8);\ - SQUASHFS_SWAP((s)->inode_number, d, 24, 16);\ -} - -#define SQUASHFS_SWAP_FRAGMENT_ENTRY(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry));\ - SQUASHFS_SWAP((s)->start_block, d, 0, 64);\ - SQUASHFS_SWAP((s)->size, d, 64, 32);\ -} - -#define SQUASHFS_SWAP_INODE_T(s, d) SQUASHFS_SWAP_LONG_LONGS(s, d, 1) - -#define SQUASHFS_SWAP_SHORTS(s, d, n) {\ +#define SQUASHFS3_SWAP_SUPER_BLOCK(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, sizeof(struct squashfs3_super_block));\ + SQUASHFS3_SWAP((s)->s_magic, d, 0, 32);\ + SQUASHFS3_SWAP((s)->inodes, d, 32, 32);\ + SQUASHFS3_SWAP((s)->bytes_used_2, d, 64, 32);\ + SQUASHFS3_SWAP((s)->uid_start_2, d, 96, 32);\ + SQUASHFS3_SWAP((s)->guid_start_2, d, 128, 32);\ + SQUASHFS3_SWAP((s)->inode_table_start_2, d, 160, 32);\ + SQUASHFS3_SWAP((s)->directory_table_start_2, d, 192, 32);\ + SQUASHFS3_SWAP((s)->s_major, d, 224, 16);\ + SQUASHFS3_SWAP((s)->s_minor, d, 240, 16);\ + SQUASHFS3_SWAP((s)->block_size_1, d, 256, 16);\ + SQUASHFS3_SWAP((s)->block_log, d, 272, 16);\ + SQUASHFS3_SWAP((s)->flags, d, 288, 8);\ + SQUASHFS3_SWAP((s)->no_uids, d, 296, 8);\ + SQUASHFS3_SWAP((s)->no_guids, d, 304, 8);\ + SQUASHFS3_SWAP((s)->mkfs_time, d, 312, 32);\ + SQUASHFS3_SWAP((s)->root_inode, d, 344, 64);\ + SQUASHFS3_SWAP((s)->block_size, d, 408, 32);\ + SQUASHFS3_SWAP((s)->fragments, d, 440, 32);\ + SQUASHFS3_SWAP((s)->fragment_table_start_2, d, 472, 32);\ + SQUASHFS3_SWAP((s)->bytes_used, d, 504, 64);\ + SQUASHFS3_SWAP((s)->uid_start, d, 568, 64);\ + SQUASHFS3_SWAP((s)->guid_start, d, 632, 64);\ + SQUASHFS3_SWAP((s)->inode_table_start, d, 696, 64);\ + SQUASHFS3_SWAP((s)->directory_table_start, d, 760, 64);\ + SQUASHFS3_SWAP((s)->fragment_table_start, d, 824, 64);\ + SQUASHFS3_SWAP((s)->lookup_table_start, d, 888, 64);\ +} + +#define SQUASHFS3_SWAP_BASE_INODE_CORE(s, d, n)\ + SQUASHFS3_MEMSET(s, d, n);\ + SQUASHFS3_SWAP((s)->inode_type, d, 0, 4);\ + SQUASHFS3_SWAP((s)->mode, d, 4, 12);\ + SQUASHFS3_SWAP((s)->uid, d, 16, 8);\ + SQUASHFS3_SWAP((s)->guid, d, 24, 8);\ + SQUASHFS3_SWAP((s)->mtime, d, 32, 32);\ + SQUASHFS3_SWAP((s)->inode_number, d, 64, 32); + +#define SQUASHFS3_SWAP_BASE_INODE_HEADER(s, d, n) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE(s, d, n)\ +} + +#define SQUASHFS3_SWAP_IPC_INODE_HEADER(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE(s, d, \ + sizeof(struct squashfs3_ipc_inode_header))\ + SQUASHFS3_SWAP((s)->nlink, d, 96, 32);\ +} + +#define SQUASHFS3_SWAP_DEV_INODE_HEADER(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE(s, d, \ + sizeof(struct squashfs3_dev_inode_header)); \ + SQUASHFS3_SWAP((s)->nlink, d, 96, 32);\ + SQUASHFS3_SWAP((s)->rdev, d, 128, 16);\ +} + +#define SQUASHFS3_SWAP_SYMLINK_INODE_HEADER(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE(s, d, \ + sizeof(struct squashfs3_symlink_inode_header));\ + SQUASHFS3_SWAP((s)->nlink, d, 96, 32);\ + SQUASHFS3_SWAP((s)->symlink_size, d, 128, 16);\ +} + +#define SQUASHFS3_SWAP_REG_INODE_HEADER(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE(s, d, \ + sizeof(struct squashfs3_reg_inode_header));\ + SQUASHFS3_SWAP((s)->start_block, d, 96, 64);\ + SQUASHFS3_SWAP((s)->fragment, d, 160, 32);\ + SQUASHFS3_SWAP((s)->offset, d, 192, 32);\ + SQUASHFS3_SWAP((s)->file_size, d, 224, 32);\ +} + +#define SQUASHFS3_SWAP_LREG_INODE_HEADER(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE(s, d, \ + sizeof(struct squashfs3_lreg_inode_header));\ + SQUASHFS3_SWAP((s)->nlink, d, 96, 32);\ + SQUASHFS3_SWAP((s)->start_block, d, 128, 64);\ + SQUASHFS3_SWAP((s)->fragment, d, 192, 32);\ + SQUASHFS3_SWAP((s)->offset, d, 224, 32);\ + SQUASHFS3_SWAP((s)->file_size, d, 256, 64);\ +} + +#define SQUASHFS3_SWAP_DIR_INODE_HEADER(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE(s, d, \ + sizeof(struct squashfs3_dir_inode_header));\ + SQUASHFS3_SWAP((s)->nlink, d, 96, 32);\ + SQUASHFS3_SWAP((s)->file_size, d, 128, 19);\ + SQUASHFS3_SWAP((s)->offset, d, 147, 13);\ + SQUASHFS3_SWAP((s)->start_block, d, 160, 32);\ + SQUASHFS3_SWAP((s)->parent_inode, d, 192, 32);\ +} + +#define SQUASHFS3_SWAP_LDIR_INODE_HEADER(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE(s, d, \ + sizeof(struct squashfs3_ldir_inode_header));\ + SQUASHFS3_SWAP((s)->nlink, d, 96, 32);\ + SQUASHFS3_SWAP((s)->file_size, d, 128, 27);\ + SQUASHFS3_SWAP((s)->offset, d, 155, 13);\ + SQUASHFS3_SWAP((s)->start_block, d, 168, 32);\ + SQUASHFS3_SWAP((s)->i_count, d, 200, 16);\ + SQUASHFS3_SWAP((s)->parent_inode, d, 216, 32);\ +} + +#define SQUASHFS3_SWAP_DIR_INDEX(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, sizeof(struct squashfs3_dir_index));\ + SQUASHFS3_SWAP((s)->index, d, 0, 32);\ + SQUASHFS3_SWAP((s)->start_block, d, 32, 32);\ + SQUASHFS3_SWAP((s)->size, d, 64, 8);\ +} + +#define SQUASHFS3_SWAP_DIR_HEADER(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, sizeof(struct squashfs3_dir_header));\ + SQUASHFS3_SWAP((s)->count, d, 0, 8);\ + SQUASHFS3_SWAP((s)->start_block, d, 8, 32);\ + SQUASHFS3_SWAP((s)->inode_number, d, 40, 32);\ +} + +#define SQUASHFS3_SWAP_DIR_ENTRY(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, sizeof(struct squashfs3_dir_entry));\ + SQUASHFS3_SWAP((s)->offset, d, 0, 13);\ + SQUASHFS3_SWAP((s)->type, d, 13, 3);\ + SQUASHFS3_SWAP((s)->size, d, 16, 8);\ + SQUASHFS3_SWAP((s)->inode_number, d, 24, 16);\ +} + +#define SQUASHFS3_SWAP_FRAGMENT_ENTRY(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, sizeof(struct squashfs3_fragment_entry));\ + SQUASHFS3_SWAP((s)->start_block, d, 0, 64);\ + SQUASHFS3_SWAP((s)->size, d, 64, 32);\ +} + +#define SQUASHFS3_SWAP_INODE_T(s, d) SQUASHFS3_SWAP_LONG_LONGS(s, d, 1) + +#define SQUASHFS3_SWAP_SHORTS(s, d, n) {\ int entry;\ int bit_position;\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, n * 2);\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, n * 2);\ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \ 16)\ - SQUASHFS_SWAP(s[entry], d, bit_position, 16);\ + SQUASHFS3_SWAP(s[entry], d, bit_position, 16);\ } -#define SQUASHFS_SWAP_INTS(s, d, n) {\ +#define SQUASHFS3_SWAP_INTS(s, d, n) {\ int entry;\ int bit_position;\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, n * 4);\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, n * 4);\ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \ 32)\ - SQUASHFS_SWAP(s[entry], d, bit_position, 32);\ + SQUASHFS3_SWAP(s[entry], d, bit_position, 32);\ } -#define SQUASHFS_SWAP_LONG_LONGS(s, d, n) {\ +#define SQUASHFS3_SWAP_LONG_LONGS(s, d, n) {\ int entry;\ int bit_position;\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, n * 8);\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, n * 8);\ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \ 64)\ - SQUASHFS_SWAP(s[entry], d, bit_position, 64);\ + SQUASHFS3_SWAP(s[entry], d, bit_position, 64);\ } -#define SQUASHFS_SWAP_DATA(s, d, n, bits) {\ +#define SQUASHFS3_SWAP_DATA(s, d, n, bits) {\ int entry;\ int bit_position;\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, n * bits / 8);\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, n * bits / 8);\ for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \ bits)\ - SQUASHFS_SWAP(s[entry], d, bit_position, bits);\ + SQUASHFS3_SWAP(s[entry], d, bit_position, bits);\ } -#define SQUASHFS_SWAP_FRAGMENT_INDEXES(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n) -#define SQUASHFS_SWAP_LOOKUP_BLOCKS(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n) +#define SQUASHFS3_SWAP_FRAGMENT_INDEXES(s, d, n) SQUASHFS3_SWAP_LONG_LONGS(s, d, n) +#define SQUASHFS3_SWAP_LOOKUP_BLOCKS(s, d, n) SQUASHFS3_SWAP_LONG_LONGS(s, d, n) -#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY +#ifdef CONFIG_SQUASHFS3_1_0_COMPATIBILITY -struct squashfs_base_inode_header_1 { +struct squashfs3_base_inode_header_1 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:4; /* index into uid table */ unsigned int guid:4; /* index into guid table */ } __attribute__ ((packed)); -struct squashfs_ipc_inode_header_1 { +struct squashfs3_ipc_inode_header_1 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:4; /* index into uid table */ @@ -582,7 +582,7 @@ struct squashfs_ipc_inode_header_1 { unsigned int offset:4; } __attribute__ ((packed)); -struct squashfs_dev_inode_header_1 { +struct squashfs3_dev_inode_header_1 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:4; /* index into uid table */ @@ -590,7 +590,7 @@ struct squashfs_dev_inode_header_1 { unsigned short rdev; } __attribute__ ((packed)); -struct squashfs_symlink_inode_header_1 { +struct squashfs3_symlink_inode_header_1 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:4; /* index into uid table */ @@ -599,7 +599,7 @@ struct squashfs_symlink_inode_header_1 { char symlink[0]; } __attribute__ ((packed)); -struct squashfs_reg_inode_header_1 { +struct squashfs3_reg_inode_header_1 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:4; /* index into uid table */ @@ -610,7 +610,7 @@ struct squashfs_reg_inode_header_1 { unsigned short block_list[0]; } __attribute__ ((packed)); -struct squashfs_dir_inode_header_1 { +struct squashfs3_dir_inode_header_1 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:4; /* index into uid table */ @@ -621,94 +621,94 @@ struct squashfs_dir_inode_header_1 { unsigned int start_block:24; } __attribute__ ((packed)); -union squashfs_inode_header_1 { - struct squashfs_base_inode_header_1 base; - struct squashfs_dev_inode_header_1 dev; - struct squashfs_symlink_inode_header_1 symlink; - struct squashfs_reg_inode_header_1 reg; - struct squashfs_dir_inode_header_1 dir; - struct squashfs_ipc_inode_header_1 ipc; +union squashfs3_inode_header_1 { + struct squashfs3_base_inode_header_1 base; + struct squashfs3_dev_inode_header_1 dev; + struct squashfs3_symlink_inode_header_1 symlink; + struct squashfs3_reg_inode_header_1 reg; + struct squashfs3_dir_inode_header_1 dir; + struct squashfs3_ipc_inode_header_1 ipc; }; -#define SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n) \ - SQUASHFS_MEMSET(s, d, n);\ - SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\ - SQUASHFS_SWAP((s)->mode, d, 4, 12);\ - SQUASHFS_SWAP((s)->uid, d, 16, 4);\ - SQUASHFS_SWAP((s)->guid, d, 20, 4); +#define SQUASHFS3_SWAP_BASE_INODE_CORE_1(s, d, n) \ + SQUASHFS3_MEMSET(s, d, n);\ + SQUASHFS3_SWAP((s)->inode_type, d, 0, 4);\ + SQUASHFS3_SWAP((s)->mode, d, 4, 12);\ + SQUASHFS3_SWAP((s)->uid, d, 16, 4);\ + SQUASHFS3_SWAP((s)->guid, d, 20, 4); -#define SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, n) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n)\ +#define SQUASHFS3_SWAP_BASE_INODE_HEADER_1(s, d, n) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_1(s, d, n)\ } -#define SQUASHFS_SWAP_IPC_INODE_HEADER_1(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \ - sizeof(struct squashfs_ipc_inode_header_1));\ - SQUASHFS_SWAP((s)->type, d, 24, 4);\ - SQUASHFS_SWAP((s)->offset, d, 28, 4);\ +#define SQUASHFS3_SWAP_IPC_INODE_HEADER_1(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_1(s, d, \ + sizeof(struct squashfs3_ipc_inode_header_1));\ + SQUASHFS3_SWAP((s)->type, d, 24, 4);\ + SQUASHFS3_SWAP((s)->offset, d, 28, 4);\ } -#define SQUASHFS_SWAP_DEV_INODE_HEADER_1(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \ - sizeof(struct squashfs_dev_inode_header_1));\ - SQUASHFS_SWAP((s)->rdev, d, 24, 16);\ +#define SQUASHFS3_SWAP_DEV_INODE_HEADER_1(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_1(s, d, \ + sizeof(struct squashfs3_dev_inode_header_1));\ + SQUASHFS3_SWAP((s)->rdev, d, 24, 16);\ } -#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \ - sizeof(struct squashfs_symlink_inode_header_1));\ - SQUASHFS_SWAP((s)->symlink_size, d, 24, 16);\ +#define SQUASHFS3_SWAP_SYMLINK_INODE_HEADER_1(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_1(s, d, \ + sizeof(struct squashfs3_symlink_inode_header_1));\ + SQUASHFS3_SWAP((s)->symlink_size, d, 24, 16);\ } -#define SQUASHFS_SWAP_REG_INODE_HEADER_1(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \ - sizeof(struct squashfs_reg_inode_header_1));\ - SQUASHFS_SWAP((s)->mtime, d, 24, 32);\ - SQUASHFS_SWAP((s)->start_block, d, 56, 32);\ - SQUASHFS_SWAP((s)->file_size, d, 88, 32);\ +#define SQUASHFS3_SWAP_REG_INODE_HEADER_1(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_1(s, d, \ + sizeof(struct squashfs3_reg_inode_header_1));\ + SQUASHFS3_SWAP((s)->mtime, d, 24, 32);\ + SQUASHFS3_SWAP((s)->start_block, d, 56, 32);\ + SQUASHFS3_SWAP((s)->file_size, d, 88, 32);\ } -#define SQUASHFS_SWAP_DIR_INODE_HEADER_1(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \ - sizeof(struct squashfs_dir_inode_header_1));\ - SQUASHFS_SWAP((s)->file_size, d, 24, 19);\ - SQUASHFS_SWAP((s)->offset, d, 43, 13);\ - SQUASHFS_SWAP((s)->mtime, d, 56, 32);\ - SQUASHFS_SWAP((s)->start_block, d, 88, 24);\ +#define SQUASHFS3_SWAP_DIR_INODE_HEADER_1(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_1(s, d, \ + sizeof(struct squashfs3_dir_inode_header_1));\ + SQUASHFS3_SWAP((s)->file_size, d, 24, 19);\ + SQUASHFS3_SWAP((s)->offset, d, 43, 13);\ + SQUASHFS3_SWAP((s)->mtime, d, 56, 32);\ + SQUASHFS3_SWAP((s)->start_block, d, 88, 24);\ } #endif -#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY +#ifdef CONFIG_SQUASHFS3_2_0_COMPATIBILITY -struct squashfs_dir_index_2 { +struct squashfs3_dir_index_2 { unsigned int index:27; unsigned int start_block:29; unsigned char size; unsigned char name[0]; } __attribute__ ((packed)); -struct squashfs_base_inode_header_2 { +struct squashfs3_base_inode_header_2 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:8; /* index into uid table */ unsigned int guid:8; /* index into guid table */ } __attribute__ ((packed)); -struct squashfs_ipc_inode_header_2 { +struct squashfs3_ipc_inode_header_2 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:8; /* index into uid table */ unsigned int guid:8; /* index into guid table */ } __attribute__ ((packed)); -struct squashfs_dev_inode_header_2 { +struct squashfs3_dev_inode_header_2 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:8; /* index into uid table */ @@ -716,7 +716,7 @@ struct squashfs_dev_inode_header_2 { unsigned short rdev; } __attribute__ ((packed)); -struct squashfs_symlink_inode_header_2 { +struct squashfs3_symlink_inode_header_2 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:8; /* index into uid table */ @@ -725,7 +725,7 @@ struct squashfs_symlink_inode_header_2 { char symlink[0]; } __attribute__ ((packed)); -struct squashfs_reg_inode_header_2 { +struct squashfs3_reg_inode_header_2 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:8; /* index into uid table */ @@ -738,7 +738,7 @@ struct squashfs_reg_inode_header_2 { unsigned short block_list[0]; } __attribute__ ((packed)); -struct squashfs_dir_inode_header_2 { +struct squashfs3_dir_inode_header_2 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:8; /* index into uid table */ @@ -749,7 +749,7 @@ struct squashfs_dir_inode_header_2 { unsigned int start_block:24; } __attribute__ ((packed)); -struct squashfs_ldir_inode_header_2 { +struct squashfs3_ldir_inode_header_2 { unsigned int inode_type:4; unsigned int mode:12; /* protection */ unsigned int uid:8; /* index into uid table */ @@ -759,142 +759,142 @@ struct squashfs_ldir_inode_header_2 { unsigned int mtime; unsigned int start_block:24; unsigned int i_count:16; - struct squashfs_dir_index_2 index[0]; + struct squashfs3_dir_index_2 index[0]; } __attribute__ ((packed)); -union squashfs_inode_header_2 { - struct squashfs_base_inode_header_2 base; - struct squashfs_dev_inode_header_2 dev; - struct squashfs_symlink_inode_header_2 symlink; - struct squashfs_reg_inode_header_2 reg; - struct squashfs_dir_inode_header_2 dir; - struct squashfs_ldir_inode_header_2 ldir; - struct squashfs_ipc_inode_header_2 ipc; +union squashfs3_inode_header_2 { + struct squashfs3_base_inode_header_2 base; + struct squashfs3_dev_inode_header_2 dev; + struct squashfs3_symlink_inode_header_2 symlink; + struct squashfs3_reg_inode_header_2 reg; + struct squashfs3_dir_inode_header_2 dir; + struct squashfs3_ldir_inode_header_2 ldir; + struct squashfs3_ipc_inode_header_2 ipc; }; -struct squashfs_dir_header_2 { +struct squashfs3_dir_header_2 { unsigned int count:8; unsigned int start_block:24; } __attribute__ ((packed)); -struct squashfs_dir_entry_2 { +struct squashfs3_dir_entry_2 { unsigned int offset:13; unsigned int type:3; unsigned int size:8; char name[0]; } __attribute__ ((packed)); -struct squashfs_fragment_entry_2 { +struct squashfs3_fragment_entry_2 { unsigned int start_block; unsigned int size; } __attribute__ ((packed)); -#define SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\ - SQUASHFS_MEMSET(s, d, n);\ - SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\ - SQUASHFS_SWAP((s)->mode, d, 4, 12);\ - SQUASHFS_SWAP((s)->uid, d, 16, 8);\ - SQUASHFS_SWAP((s)->guid, d, 24, 8);\ +#define SQUASHFS3_SWAP_BASE_INODE_CORE_2(s, d, n)\ + SQUASHFS3_MEMSET(s, d, n);\ + SQUASHFS3_SWAP((s)->inode_type, d, 0, 4);\ + SQUASHFS3_SWAP((s)->mode, d, 4, 12);\ + SQUASHFS3_SWAP((s)->uid, d, 16, 8);\ + SQUASHFS3_SWAP((s)->guid, d, 24, 8);\ -#define SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, n) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\ +#define SQUASHFS3_SWAP_BASE_INODE_HEADER_2(s, d, n) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_2(s, d, n)\ } -#define SQUASHFS_SWAP_IPC_INODE_HEADER_2(s, d) \ - SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, sizeof(struct squashfs_ipc_inode_header_2)) +#define SQUASHFS3_SWAP_IPC_INODE_HEADER_2(s, d) \ + SQUASHFS3_SWAP_BASE_INODE_HEADER_2(s, d, sizeof(struct squashfs3_ipc_inode_header_2)) -#define SQUASHFS_SWAP_DEV_INODE_HEADER_2(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \ - sizeof(struct squashfs_dev_inode_header_2)); \ - SQUASHFS_SWAP((s)->rdev, d, 32, 16);\ +#define SQUASHFS3_SWAP_DEV_INODE_HEADER_2(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_2(s, d, \ + sizeof(struct squashfs3_dev_inode_header_2)); \ + SQUASHFS3_SWAP((s)->rdev, d, 32, 16);\ } -#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \ - sizeof(struct squashfs_symlink_inode_header_2));\ - SQUASHFS_SWAP((s)->symlink_size, d, 32, 16);\ +#define SQUASHFS3_SWAP_SYMLINK_INODE_HEADER_2(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_2(s, d, \ + sizeof(struct squashfs3_symlink_inode_header_2));\ + SQUASHFS3_SWAP((s)->symlink_size, d, 32, 16);\ } -#define SQUASHFS_SWAP_REG_INODE_HEADER_2(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \ - sizeof(struct squashfs_reg_inode_header_2));\ - SQUASHFS_SWAP((s)->mtime, d, 32, 32);\ - SQUASHFS_SWAP((s)->start_block, d, 64, 32);\ - SQUASHFS_SWAP((s)->fragment, d, 96, 32);\ - SQUASHFS_SWAP((s)->offset, d, 128, 32);\ - SQUASHFS_SWAP((s)->file_size, d, 160, 32);\ +#define SQUASHFS3_SWAP_REG_INODE_HEADER_2(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_2(s, d, \ + sizeof(struct squashfs3_reg_inode_header_2));\ + SQUASHFS3_SWAP((s)->mtime, d, 32, 32);\ + SQUASHFS3_SWAP((s)->start_block, d, 64, 32);\ + SQUASHFS3_SWAP((s)->fragment, d, 96, 32);\ + SQUASHFS3_SWAP((s)->offset, d, 128, 32);\ + SQUASHFS3_SWAP((s)->file_size, d, 160, 32);\ } -#define SQUASHFS_SWAP_DIR_INODE_HEADER_2(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \ - sizeof(struct squashfs_dir_inode_header_2));\ - SQUASHFS_SWAP((s)->file_size, d, 32, 19);\ - SQUASHFS_SWAP((s)->offset, d, 51, 13);\ - SQUASHFS_SWAP((s)->mtime, d, 64, 32);\ - SQUASHFS_SWAP((s)->start_block, d, 96, 24);\ +#define SQUASHFS3_SWAP_DIR_INODE_HEADER_2(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_2(s, d, \ + sizeof(struct squashfs3_dir_inode_header_2));\ + SQUASHFS3_SWAP((s)->file_size, d, 32, 19);\ + SQUASHFS3_SWAP((s)->offset, d, 51, 13);\ + SQUASHFS3_SWAP((s)->mtime, d, 64, 32);\ + SQUASHFS3_SWAP((s)->start_block, d, 96, 24);\ } -#define SQUASHFS_SWAP_LDIR_INODE_HEADER_2(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \ - sizeof(struct squashfs_ldir_inode_header_2));\ - SQUASHFS_SWAP((s)->file_size, d, 32, 27);\ - SQUASHFS_SWAP((s)->offset, d, 59, 13);\ - SQUASHFS_SWAP((s)->mtime, d, 72, 32);\ - SQUASHFS_SWAP((s)->start_block, d, 104, 24);\ - SQUASHFS_SWAP((s)->i_count, d, 128, 16);\ +#define SQUASHFS3_SWAP_LDIR_INODE_HEADER_2(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_SWAP_BASE_INODE_CORE_2(s, d, \ + sizeof(struct squashfs3_ldir_inode_header_2));\ + SQUASHFS3_SWAP((s)->file_size, d, 32, 27);\ + SQUASHFS3_SWAP((s)->offset, d, 59, 13);\ + SQUASHFS3_SWAP((s)->mtime, d, 72, 32);\ + SQUASHFS3_SWAP((s)->start_block, d, 104, 24);\ + SQUASHFS3_SWAP((s)->i_count, d, 128, 16);\ } -#define SQUASHFS_SWAP_DIR_INDEX_2(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index_2));\ - SQUASHFS_SWAP((s)->index, d, 0, 27);\ - SQUASHFS_SWAP((s)->start_block, d, 27, 29);\ - SQUASHFS_SWAP((s)->size, d, 56, 8);\ +#define SQUASHFS3_SWAP_DIR_INDEX_2(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, sizeof(struct squashfs3_dir_index_2));\ + SQUASHFS3_SWAP((s)->index, d, 0, 27);\ + SQUASHFS3_SWAP((s)->start_block, d, 27, 29);\ + SQUASHFS3_SWAP((s)->size, d, 56, 8);\ } -#define SQUASHFS_SWAP_DIR_HEADER_2(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header_2));\ - SQUASHFS_SWAP((s)->count, d, 0, 8);\ - SQUASHFS_SWAP((s)->start_block, d, 8, 24);\ +#define SQUASHFS3_SWAP_DIR_HEADER_2(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, sizeof(struct squashfs3_dir_header_2));\ + SQUASHFS3_SWAP((s)->count, d, 0, 8);\ + SQUASHFS3_SWAP((s)->start_block, d, 8, 24);\ } -#define SQUASHFS_SWAP_DIR_ENTRY_2(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry_2));\ - SQUASHFS_SWAP((s)->offset, d, 0, 13);\ - SQUASHFS_SWAP((s)->type, d, 13, 3);\ - SQUASHFS_SWAP((s)->size, d, 16, 8);\ +#define SQUASHFS3_SWAP_DIR_ENTRY_2(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, sizeof(struct squashfs3_dir_entry_2));\ + SQUASHFS3_SWAP((s)->offset, d, 0, 13);\ + SQUASHFS3_SWAP((s)->type, d, 13, 3);\ + SQUASHFS3_SWAP((s)->size, d, 16, 8);\ } -#define SQUASHFS_SWAP_FRAGMENT_ENTRY_2(s, d) {\ - SQUASHFS_SWAP_START\ - SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry_2));\ - SQUASHFS_SWAP((s)->start_block, d, 0, 32);\ - SQUASHFS_SWAP((s)->size, d, 32, 32);\ +#define SQUASHFS3_SWAP_FRAGMENT_ENTRY_2(s, d) {\ + SQUASHFS3_SWAP_START\ + SQUASHFS3_MEMSET(s, d, sizeof(struct squashfs3_fragment_entry_2));\ + SQUASHFS3_SWAP((s)->start_block, d, 0, 32);\ + SQUASHFS3_SWAP((s)->size, d, 32, 32);\ } -#define SQUASHFS_SWAP_FRAGMENT_INDEXES_2(s, d, n) SQUASHFS_SWAP_INTS(s, d, n) +#define SQUASHFS3_SWAP_FRAGMENT_INDEXES_2(s, d, n) SQUASHFS3_SWAP_INTS(s, d, n) /* fragment and fragment table defines */ -#define SQUASHFS_FRAGMENT_BYTES_2(A) (A * sizeof(struct squashfs_fragment_entry_2)) +#define SQUASHFS3_FRAGMENT_BYTES_2(A) (A * sizeof(struct squashfs3_fragment_entry_2)) -#define SQUASHFS_FRAGMENT_INDEX_2(A) (SQUASHFS_FRAGMENT_BYTES_2(A) / \ - SQUASHFS_METADATA_SIZE) +#define SQUASHFS3_FRAGMENT_INDEX_2(A) (SQUASHFS3_FRAGMENT_BYTES_2(A) / \ + SQUASHFS3_METADATA_SIZE) -#define SQUASHFS_FRAGMENT_INDEX_OFFSET_2(A) (SQUASHFS_FRAGMENT_BYTES_2(A) % \ - SQUASHFS_METADATA_SIZE) +#define SQUASHFS3_FRAGMENT_INDEX_OFFSET_2(A) (SQUASHFS3_FRAGMENT_BYTES_2(A) % \ + SQUASHFS3_METADATA_SIZE) -#define SQUASHFS_FRAGMENT_INDEXES_2(A) ((SQUASHFS_FRAGMENT_BYTES_2(A) + \ - SQUASHFS_METADATA_SIZE - 1) / \ - SQUASHFS_METADATA_SIZE) +#define SQUASHFS3_FRAGMENT_INDEXES_2(A) ((SQUASHFS3_FRAGMENT_BYTES_2(A) + \ + SQUASHFS3_METADATA_SIZE - 1) / \ + SQUASHFS3_METADATA_SIZE) -#define SQUASHFS_FRAGMENT_INDEX_BYTES_2(A) (SQUASHFS_FRAGMENT_INDEXES_2(A) *\ +#define SQUASHFS3_FRAGMENT_INDEX_BYTES_2(A) (SQUASHFS3_FRAGMENT_INDEXES_2(A) *\ sizeof(int)) #endif @@ -911,15 +911,15 @@ struct squashfs_fragment_entry_2 { #ifdef __BIG_ENDIAN /* convert from little endian to big endian */ -#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, \ +#define SQUASHFS3_SWAP(value, p, pos, tbits) _SQUASHFS3_SWAP(value, p, pos, \ tbits, b_pos) #else /* convert from big endian to little endian */ -#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, \ +#define SQUASHFS3_SWAP(value, p, pos, tbits) _SQUASHFS3_SWAP(value, p, pos, \ tbits, 64 - tbits - b_pos) #endif -#define _SQUASHFS_SWAP(value, p, pos, tbits, SHIFT) {\ +#define _SQUASHFS3_SWAP(value, p, pos, tbits, SHIFT) {\ b_pos = pos % 8;\ val = 0;\ s = (unsigned char *)p + (pos / 8);\ @@ -929,7 +929,7 @@ struct squashfs_fragment_entry_2 { value = (val >> (SHIFT))/* & ((1 << tbits) - 1)*/;\ } -#define SQUASHFS_MEMSET(s, d, n) memset(s, 0, n); +#define SQUASHFS3_MEMSET(s, d, n) memset(s, 0, n); #endif #endif diff --git a/include/linux/squashfs3_fs_i.h b/include/linux/squashfs3_fs_i.h index d5b51cb..bcf84ab 100644 --- a/include/linux/squashfs3_fs_i.h +++ b/include/linux/squashfs3_fs_i.h @@ -1,5 +1,5 @@ -#ifndef SQUASHFS_FS_I -#define SQUASHFS_FS_I +#ifndef SQUASHFS3_FS_I +#define SQUASHFS3_FS_I /* * Squashfs * @@ -23,7 +23,7 @@ * squashfs3_fs_i.h */ -struct squashfs_inode_info { +struct squashfs3_inode_info { long long start_block; unsigned int offset; union { diff --git a/include/linux/squashfs3_fs_sb.h b/include/linux/squashfs3_fs_sb.h index a4bbca9..18b4cdf 100644 --- a/include/linux/squashfs3_fs_sb.h +++ b/include/linux/squashfs3_fs_sb.h @@ -1,5 +1,5 @@ -#ifndef SQUASHFS_FS_SB -#define SQUASHFS_FS_SB +#ifndef SQUASHFS3_FS_SB +#define SQUASHFS3_FS_SB /* * Squashfs * @@ -25,7 +25,7 @@ #include -struct squashfs_cache_entry { +struct squashfs3_cache_entry { long long block; int length; int locked; @@ -37,7 +37,7 @@ struct squashfs_cache_entry { char *data; }; -struct squashfs_cache { +struct squashfs3_cache { char *name; int entries; int block_size; @@ -47,16 +47,16 @@ struct squashfs_cache { int use_vmalloc; spinlock_t lock; wait_queue_head_t wait_queue; - struct squashfs_cache_entry entry[0]; + struct squashfs3_cache_entry entry[0]; }; -struct squashfs_sb_info { - struct squashfs_super_block sblk; +struct squashfs3_sb_info { + struct squashfs3_super_block sblk; int devblksize; int devblksize_log2; int swap; - struct squashfs_cache *block_cache; - struct squashfs_cache *fragment_cache; + struct squashfs3_cache *block_cache; + struct squashfs3_cache *fragment_cache; int next_meta_index; unsigned int *uid; unsigned int *guid; @@ -69,7 +69,7 @@ struct squashfs_sb_info { struct meta_index *meta_index; z_stream stream; long long *inode_lookup_table; - int (*read_inode)(struct inode *i, squashfs_inode_t \ + int (*read_inode)(struct inode *i, squashfs3_inode_t \ inode); long long (*read_blocklist)(struct inode *inode, int \ index, int readahead_blks, char *block_list, \ diff --git a/init/do_mounts_rd.c b/init/do_mounts_rd.c index 37627bb..99c1b91 100644 --- a/init/do_mounts_rd.c +++ b/init/do_mounts_rd.c @@ -38,7 +38,7 @@ static int __init crd_load(int in_fd, int out_fd); * numbers could not be found. * * We currently check for the following magic numbers: - * squashfs + * squashfs3 * minix * ext2 * romfs @@ -53,7 +53,7 @@ identify_ramdisk_image(int fd, int start_block) struct ext2_super_block *ext2sb; struct romfs_super_block *romfsb; struct cramfs_super *cramfsb; - struct squashfs_super_block *squashfsb; + struct squashfs3_super_block *squashfs3sb; int nblocks = -1; unsigned char *buf; @@ -65,7 +65,7 @@ identify_ramdisk_image(int fd, int start_block) ext2sb = (struct ext2_super_block *) buf; romfsb = (struct romfs_super_block *) buf; cramfsb = (struct cramfs_super *) buf; - squashfsb = (struct squashfs_super_block *) buf; + squashfs3sb = (struct squashfs3_super_block *) buf; memset(buf, 0xe5, size); /* @@ -103,15 +103,15 @@ identify_ramdisk_image(int fd, int start_block) goto done; } - /* squashfs is at block zero too */ - if (squashfsb->s_magic == SQUASHFS_MAGIC) { + /* squashfs3 is at block zero too */ + if (squashfs3sb->s_magic == SQUASHFS3_MAGIC) { printk(KERN_NOTICE - "RAMDISK: squashfs filesystem found at block %d\n", + "RAMDISK: squashfs3 filesystem found at block %d\n", start_block); - if (squashfsb->s_major < 3) - nblocks = (squashfsb->bytes_used_2+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS; + if (squashfs3sb->s_major < 3) + nblocks = (squashfs3sb->bytes_used_2+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS; else - nblocks = (squashfsb->bytes_used+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS; + nblocks = (squashfs3sb->bytes_used+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS; goto done; } -- 1.6.4.4