diff -ruN linux-2.4.20-WRTup/fs/Config.in linux-2.4.20-WRTstp/fs/Config.in --- linux-2.4.20-WRTup/fs/Config.in 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/fs/Config.in 2005-11-08 06:24:42.000000000 -0800 @@ -47,7 +47,6 @@ int 'JFFS2 debugging verbosity (0 = quiet, 2 = noisy)' CONFIG_JFFS2_FS_DEBUG 0 fi tristate 'Compressed ROM file system support' CONFIG_CRAMFS -tristate 'Squashed file system support' CONFIG_SQUASHFS bool 'Virtual memory file system support (former shm fs)' CONFIG_TMPFS define_bool CONFIG_RAMFS y diff -ruN linux-2.4.20-WRTup/fs/Makefile linux-2.4.20-WRTstp/fs/Makefile --- linux-2.4.20-WRTup/fs/Makefile 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/fs/Makefile 2005-11-08 06:24:43.000000000 -0800 @@ -68,7 +68,6 @@ subdir-$(CONFIG_SUN_OPENPROMFS) += openpromfs subdir-$(CONFIG_BEFS_FS) += befs subdir-$(CONFIG_JFS_FS) += jfs -subdir-$(CONFIG_SQUASHFS) += squashfs obj-$(CONFIG_BINFMT_AOUT) += binfmt_aout.o diff -ruN linux-2.4.20-WRTup/fs/squashfs/inode.c linux-2.4.20-WRTstp/fs/squashfs/inode.c --- linux-2.4.20-WRTup/fs/squashfs/inode.c 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/fs/squashfs/inode.c 1969-12-31 16:00:00.000000000 -0800 @@ -1,1515 +0,0 @@ -/* - * Squashfs - a compressed read only filesystem for Linux - * - * Copyright (c) 2002, 2003, 2004 Phillip Lougher - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2, - * or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * Squashfs - a compressed read only filesystem for Linux - * - * inode.c - */ - -#define SQUASHFS_1_0_COMPATIBILITY - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifdef SQUASHFS_TRACE -#define TRACE(s, args...) printk(KERN_NOTICE "SQUASHFS: "s, ## args) -#else -#define TRACE(s, args...) {} -#endif - -#define ERROR(s, args...) printk(KERN_ERR "SQUASHFS error: "s, ## args) - -#define SERROR(s, args...) if(!silent) printk(KERN_ERR "SQUASHFS error: "s, ## args) -#define WARNING(s, args...) printk(KERN_WARNING "SQUASHFS: "s, ## args) - -static struct super_block *squashfs_read_super(struct super_block *, void *, int); -static void squashfs_put_super(struct super_block *); -static int squashfs_statfs(struct super_block *, struct statfs *); -static int squashfs_symlink_readpage(struct file *file, struct page *page); -static int squashfs_readpage(struct file *file, struct page *page); -static int squashfs_readpage4K(struct file *file, struct page *page); -static int squashfs_readdir(struct file *, void *, filldir_t); -static struct dentry *squashfs_lookup(struct inode *, struct dentry *); -static unsigned int read_data(struct super_block *s, char *buffer, - unsigned int index, unsigned int length, int, unsigned int *next_index); -static int squashfs_get_cached_block(struct super_block *s, char *buffer, - unsigned int block, unsigned int offset, int length, - unsigned int *next_block, unsigned int *next_offset); -static struct inode *squashfs_iget(struct super_block *s, squashfs_inode inode); -static unsigned int read_blocklist(struct inode *inode, int index, int readahead_blks, - char *block_list, char **block_p, unsigned int *bsize); -static void squashfs_put_super(struct super_block *s); - -#ifdef SQUASHFS_1_0_COMPATIBILITY -static int squashfs_readpage_lessthan4K(struct file *file, struct page *page); -static struct inode *squashfs_iget_1(struct super_block *s, squashfs_inode inode); -static unsigned int read_blocklist_1(struct inode *inode, int index, int readahead_blks, - char *block_list, char **block_p, unsigned int *bsize); -#endif - -DECLARE_MUTEX(read_data_mutex); - -static z_stream stream; - -static DECLARE_FSTYPE_DEV(squashfs_fs_type, "squashfs", squashfs_read_super); - -static unsigned char squashfs_filetype_table[] = { - DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK -}; - -static struct super_operations squashfs_ops = { - statfs: squashfs_statfs, - put_super: squashfs_put_super, -}; - -static struct address_space_operations squashfs_symlink_aops = { - readpage: squashfs_symlink_readpage -}; - -static struct address_space_operations squashfs_aops = { - readpage: squashfs_readpage -}; - -static struct address_space_operations squashfs_aops_4K = { - readpage: squashfs_readpage4K -}; - -#ifdef SQUASHFS_1_0_COMPATIBILITY -static struct address_space_operations squashfs_aops_lessthan4K = { - readpage: squashfs_readpage_lessthan4K -}; -#endif - -static struct file_operations squashfs_dir_ops = { - read: generic_read_dir, - readdir: squashfs_readdir -}; - -static struct inode_operations squashfs_dir_inode_ops = { - lookup: squashfs_lookup -}; - - -static unsigned int read_data(struct super_block *s, char *buffer, - unsigned int index, unsigned int length, int datablock, unsigned int *next_index) -{ - squashfs_sb_info *msBlk = &s->u.squashfs_sb; - struct buffer_head *bh[((SQUASHFS_FILE_MAX_SIZE - 1) >> msBlk->devblksize_log2) + 2]; - unsigned int offset = index & ((1 << msBlk->devblksize_log2) - 1); - unsigned int cur_index = index >> msBlk->devblksize_log2; - int bytes, avail_bytes, b, k; - char *c_buffer; - unsigned int compressed; - unsigned int c_byte = length; - - if(c_byte) { - bytes = msBlk->devblksize - offset; - if(datablock) { - c_buffer = (compressed = SQUASHFS_COMPRESSED_BLOCK(c_byte)) ? msBlk->read_data : buffer; - c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte); - } else { - c_buffer = (compressed = SQUASHFS_COMPRESSED(c_byte)) ? msBlk->read_data : buffer; - c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte); - } - - TRACE("Block @ 0x%x, %scompressed size %d\n", index, compressed ? "" : "un", (unsigned int) c_byte); - - if(!(bh[0] = sb_getblk(s, cur_index))) - goto block_release; - for(b = 1; bytes < c_byte; b++) { - if(!(bh[b] = sb_getblk(s, ++cur_index))) - goto block_release; - bytes += msBlk->devblksize; - } - ll_rw_block(READ, b, bh); - } else { - unsigned short temp; - if(!(bh[0] = sb_bread(s, cur_index))) - goto read_failure; - - if(msBlk->devblksize - offset == 1) { - if(msBlk->swap) - ((unsigned char *) &temp)[1] = *((unsigned char *) (bh[0]->b_data + offset)); - else - ((unsigned char *) &temp)[0] = *((unsigned char *) (bh[0]->b_data + offset)); - brelse(bh[0]); - if(!(bh[0] = sb_bread(s, ++cur_index))) - goto read_failure; - if(msBlk->swap) - ((unsigned char *) &temp)[0] = *((unsigned char *) bh[0]->b_data); - else - ((unsigned char *) &temp)[1] = *((unsigned char *) bh[0]->b_data); - c_byte = temp; - offset = 1; - } - else { - if(msBlk->swap) { - unsigned short temp; - ((unsigned char *) &temp)[1] = *((unsigned char *) (bh[0]->b_data + offset)); - ((unsigned char *) &temp)[0] = *((unsigned char *) (bh[0]->b_data + offset + 1)); - c_byte = temp; - } else - c_byte = *((unsigned short *) (bh[0]->b_data + offset)); - offset += 2; - } - if(SQUASHFS_CHECK_DATA(msBlk->sBlk.flags)) { - if(offset == msBlk->devblksize) { - brelse(bh[0]); - if(!(bh[0] = sb_bread(s, ++cur_index))) - goto read_failure; - offset = 0; - } - if(*((unsigned char *) (bh[0]->b_data + offset)) != SQUASHFS_MARKER_BYTE) { - ERROR("Metadata block marker corrupt @ %x\n", index); - brelse(bh[0]); - return 0; - } - offset ++; - } - - bytes = msBlk->devblksize - offset; - if(datablock) { - c_buffer = (compressed = SQUASHFS_COMPRESSED_BLOCK(c_byte)) ? msBlk->read_data : buffer; - c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte); - } else { - c_buffer = (compressed = SQUASHFS_COMPRESSED(c_byte)) ? msBlk->read_data : buffer; - c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte); - } - - TRACE("Block @ 0x%x, %scompressed size %d\n", index, compressed ? "" : "un", (unsigned int) c_byte); - - for(b = 1; bytes < c_byte; b++) { - if(!(bh[b] = sb_getblk(s, ++cur_index))) - goto block_release; - bytes += msBlk->devblksize; - } - ll_rw_block(READ, b - 1, bh + 1); - } - - if(compressed) - down(&read_data_mutex); - - for(bytes = 0, k = 0; k < b; k++) { - avail_bytes = (c_byte - bytes) > (msBlk->devblksize - offset) ? msBlk->devblksize - offset : c_byte - bytes; - wait_on_buffer(bh[k]); - memcpy(c_buffer + bytes, bh[k]->b_data + offset, avail_bytes); - bytes += avail_bytes; - offset = 0; - brelse(bh[k]); - } - - /* - * uncompress block - */ - if(compressed) { - int zlib_err; - - stream.next_in = c_buffer; - stream.avail_in = c_byte; - stream.next_out = buffer; - stream.avail_out = msBlk->read_size; - if(((zlib_err = zlib_inflateInit(&stream)) != Z_OK) || - ((zlib_err = zlib_inflate(&stream, Z_FINISH)) != Z_STREAM_END) || - ((zlib_err = zlib_inflateEnd(&stream)) != Z_OK)) { - ERROR("zlib_fs returned unexpected result 0x%x\n", zlib_err); - bytes = 0; - } else - bytes = stream.total_out; - up(&read_data_mutex); - } - - if(next_index) - *next_index = index + c_byte + (length ? 0 : (SQUASHFS_CHECK_DATA(msBlk->sBlk.flags) ? 3 : 2)); - - return bytes; - -block_release: - while(--b >= 0) brelse(bh[b]); - -read_failure: - ERROR("sb_bread failed reading block 0x%x\n", cur_index); - return 0; -} - - -static int squashfs_get_cached_block(struct super_block *s, char *buffer, - unsigned int block, unsigned int offset, int length, - unsigned int *next_block, unsigned int *next_offset) -{ - squashfs_sb_info *msBlk = &s->u.squashfs_sb; - int n, i, bytes, return_length = length; - unsigned int next_index; - - TRACE("Entered squashfs_get_cached_block [%x:%x]\n", block, offset); - - for(;;) { - for(i = 0; i < SQUASHFS_CACHED_BLKS; i++) - if(msBlk->block_cache[i].block == block) - break; - - down(&msBlk->block_cache_mutex); - if(i == SQUASHFS_CACHED_BLKS) { - /* read inode header block */ - for(i = msBlk->next_cache, n = SQUASHFS_CACHED_BLKS; n ; n --, i = (i + 1) % SQUASHFS_CACHED_BLKS) - if(msBlk->block_cache[i].block != SQUASHFS_USED_BLK) - break; - if(n == 0) { - up(&msBlk->block_cache_mutex); - sleep_on(&msBlk->waitq); - continue; - } - msBlk->next_cache = (i + 1) % SQUASHFS_CACHED_BLKS; - - if(msBlk->block_cache[i].block == SQUASHFS_INVALID_BLK) { - if(!(msBlk->block_cache[i].data = (unsigned char *) - kmalloc(SQUASHFS_METADATA_SIZE, GFP_KERNEL))) { - ERROR("Failed to allocate cache block\n"); - up(&msBlk->block_cache_mutex); - return 0; - } - } - - msBlk->block_cache[i].block = SQUASHFS_USED_BLK; - up(&msBlk->block_cache_mutex); - if(!(msBlk->block_cache[i].length = read_data(s, msBlk->block_cache[i].data, block, 0, 0, - &next_index))) { - ERROR("Unable to read cache block [%x:%x]\n", block, offset); - return 0; - } - down(&msBlk->block_cache_mutex); - wake_up(&msBlk->waitq); - msBlk->block_cache[i].block = block; - msBlk->block_cache[i].next_index = next_index; - TRACE("Read cache block [%x:%x]\n", block, offset); - } - - if(msBlk->block_cache[i].block != block) { - up(&msBlk->block_cache_mutex); - continue; - } - - if((bytes = msBlk->block_cache[i].length - offset) >= length) { - if(buffer) - memcpy(buffer, msBlk->block_cache[i].data + offset, length); - if(msBlk->block_cache[i].length - offset == length) { - *next_block = msBlk->block_cache[i].next_index; - *next_offset = 0; - } else { - *next_block = block; - *next_offset = offset + length; - } - - up(&msBlk->block_cache_mutex); - return return_length; - } else { - if(buffer) { - memcpy(buffer, msBlk->block_cache[i].data + offset, bytes); - buffer += bytes; - } - block = msBlk->block_cache[i].next_index; - up(&msBlk->block_cache_mutex); - length -= bytes; - offset = 0; - } - } -} - - -static int get_fragment_location(struct super_block *s, unsigned int fragment, unsigned int *fragment_start_block, unsigned int *fragment_size) -{ - squashfs_sb_info *msBlk = &s->u.squashfs_sb; - unsigned int start_block = msBlk->fragment_index[SQUASHFS_FRAGMENT_INDEX(fragment)]; - int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET(fragment); - squashfs_fragment_entry fragment_entry; - - if(msBlk->swap) { - squashfs_fragment_entry sfragment_entry; - - if(!squashfs_get_cached_block(s, (char *) &sfragment_entry, start_block, offset, - sizeof(sfragment_entry), &start_block, &offset)) - return 0; - SQUASHFS_SWAP_FRAGMENT_ENTRY(&fragment_entry, &sfragment_entry); - } else - if(!squashfs_get_cached_block(s, (char *) &fragment_entry, start_block, offset, - sizeof(fragment_entry), &start_block, &offset)) - return 0; - - *fragment_start_block = fragment_entry.start_block; - *fragment_size = fragment_entry.size; - - return 1; -} - - -void release_cached_fragment(squashfs_sb_info *msBlk, struct squashfs_fragment_cache *fragment) -{ - down(&msBlk->fragment_mutex); - fragment->locked --; - wake_up(&msBlk->fragment_wait_queue); - up(&msBlk->fragment_mutex); -} - - -struct squashfs_fragment_cache *get_cached_fragment(struct super_block *s, unsigned int start_block, int length) -{ - int i, n; - squashfs_sb_info *msBlk = &s->u.squashfs_sb; - - for(;;) { - down(&msBlk->fragment_mutex); - for(i = 0; i < SQUASHFS_CACHED_FRAGMENTS && msBlk->fragment[i].block != start_block; i++); - if(i == SQUASHFS_CACHED_FRAGMENTS) { - for(i = msBlk->next_fragment, n = SQUASHFS_CACHED_FRAGMENTS; - n && msBlk->fragment[i].locked; n--, i = (i + 1) % SQUASHFS_CACHED_FRAGMENTS); - - if(n == 0) { - up(&msBlk->fragment_mutex); - sleep_on(&msBlk->fragment_wait_queue); - continue; - } - msBlk->next_fragment = (msBlk->next_fragment + 1) % SQUASHFS_CACHED_FRAGMENTS; - - if(msBlk->fragment[i].data == NULL) - if(!(msBlk->fragment[i].data = (unsigned char *) - kmalloc(SQUASHFS_FILE_MAX_SIZE, GFP_KERNEL))) { - ERROR("Failed to allocate fragment cache block\n"); - up(&msBlk->fragment_mutex); - return NULL; - } - - msBlk->fragment[i].block = SQUASHFS_INVALID_BLK; - msBlk->fragment[i].locked = 1; - up(&msBlk->fragment_mutex); - if(!(msBlk->fragment[i].length = read_data(s, msBlk->fragment[i].data, start_block, length, - 1, NULL))) { - ERROR("Unable to read fragment cache block [%x]\n", start_block); - msBlk->fragment[i].locked = 0; - return NULL; - } - msBlk->fragment[i].block = start_block; - TRACE("New fragment %d, start block %d, locked %d\n", i, msBlk->fragment[i].block, msBlk->fragment[i].locked); - return &msBlk->fragment[i]; - } - - msBlk->fragment[i].locked ++; - up(&msBlk->fragment_mutex); - - TRACE("Got fragment %d, start block %d, locked %d\n", i, msBlk->fragment[i].block, msBlk->fragment[i].locked); - return &msBlk->fragment[i]; - } -} - - -#ifdef SQUASHFS_1_0_COMPATIBILITY -static struct inode *squashfs_iget_1(struct super_block *s, squashfs_inode inode) -{ - struct inode *i = new_inode(s); - squashfs_sb_info *msBlk = &s->u.squashfs_sb; - squashfs_super_block *sBlk = &msBlk->sBlk; - unsigned int block = SQUASHFS_INODE_BLK(inode) + sBlk->inode_table_start; - unsigned int offset = SQUASHFS_INODE_OFFSET(inode); - unsigned int next_block, next_offset; - squashfs_base_inode_header_1 inodeb; - - TRACE("Entered squashfs_iget_1\n"); - - if(msBlk->swap) { - squashfs_base_inode_header_1 sinodeb; - - if(!squashfs_get_cached_block(s, (char *) &sinodeb, block, offset, - sizeof(sinodeb), &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_BASE_INODE_HEADER_1(&inodeb, &sinodeb, sizeof(sinodeb)); - } else - if(!squashfs_get_cached_block(s, (char *) &inodeb, block, offset, - sizeof(inodeb), &next_block, &next_offset)) - goto failed_read; - - i->i_nlink = 1; - - i->i_mtime = sBlk->mkfs_time; - i->i_atime = sBlk->mkfs_time; - i->i_ctime = sBlk->mkfs_time; - - if(inodeb.inode_type != SQUASHFS_IPC_TYPE) - i->i_uid = msBlk->uid[((inodeb.inode_type - 1) / SQUASHFS_TYPES) * 16 + inodeb.uid]; - i->i_ino = SQUASHFS_MK_VFS_INODE(block - sBlk->inode_table_start, offset); - - i->i_mode = inodeb.mode; - - switch(inodeb.inode_type == SQUASHFS_IPC_TYPE ? SQUASHFS_IPC_TYPE : (inodeb.inode_type - 1) % SQUASHFS_TYPES + 1) { - case SQUASHFS_FILE_TYPE: { - squashfs_reg_inode_header_1 inodep; - - if(msBlk->swap) { - squashfs_reg_inode_header_1 sinodep; - - if(!squashfs_get_cached_block(s, (char *) &sinodep, block, offset, sizeof(sinodep), - &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_REG_INODE_HEADER_1(&inodep, &sinodep); - } else - if(!squashfs_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_fop = &generic_ro_fops; - if(sBlk->block_size > 4096) - i->i_data.a_ops = &squashfs_aops; - else if(sBlk->block_size == 4096) - i->i_data.a_ops = &squashfs_aops_4K; - else - i->i_data.a_ops = &squashfs_aops_lessthan4K; - i->i_mode |= S_IFREG; - i->i_mtime = inodep.mtime; - i->i_atime = inodep.mtime; - i->i_ctime = inodep.mtime; - i->i_blocks = ((i->i_size - 1) >> 9) + 1; - i->i_blksize = PAGE_CACHE_SIZE; - i->u.squashfs_i.fragment_start_block = SQUASHFS_INVALID_BLK; - i->u.squashfs_i.fragment_offset = 0; - i->u.squashfs_i.start_block = inodep.start_block; - i->u.squashfs_i.block_list_start = next_block; - i->u.squashfs_i.offset = next_offset; - TRACE("File inode %x:%x, start_block %x, block_list_start %x, offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, inodep.start_block, next_block, next_offset); - break; - } - case SQUASHFS_DIR_TYPE: { - squashfs_dir_inode_header_1 inodep; - - if(msBlk->swap) { - squashfs_dir_inode_header_1 sinodep; - - if(!squashfs_get_cached_block(s, (char *) &sinodep, block, offset, sizeof(sinodep), - &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_DIR_INODE_HEADER_1(&inodep, &sinodep); - } else - if(!squashfs_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; - i->i_fop = &squashfs_dir_ops; - i->i_mode |= S_IFDIR; - i->i_mtime = inodep.mtime; - i->i_atime = inodep.mtime; - i->i_ctime = inodep.mtime; - i->u.squashfs_i.start_block = inodep.start_block; - i->u.squashfs_i.offset = inodep.offset; - TRACE("Directory inode %x:%x, start_block %x, offset %x\n", SQUASHFS_INODE_BLK(inode), offset, - inodep.start_block, inodep.offset); - break; - } - case SQUASHFS_SYMLINK_TYPE: { - squashfs_symlink_inode_header_1 inodep; - - if(msBlk->swap) { - squashfs_symlink_inode_header_1 sinodep; - - if(!squashfs_get_cached_block(s, (char *) &sinodep, block, offset, sizeof(sinodep), - &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(&inodep, &sinodep); - } else - if(!squashfs_get_cached_block(s, (char *) &inodep, block, offset, sizeof(inodep), - &next_block, &next_offset)) - goto failed_read; - - i->i_size = inodep.symlink_size; - i->i_op = &page_symlink_inode_operations; - i->i_data.a_ops = &squashfs_symlink_aops; - i->i_mode |= S_IFLNK; - i->u.squashfs_i.start_block = next_block; - i->u.squashfs_i.offset = next_offset; - TRACE("Symbolic link inode %x:%x, start_block %x, offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, next_block, next_offset); - break; - } - case SQUASHFS_BLKDEV_TYPE: - case SQUASHFS_CHRDEV_TYPE: { - squashfs_dev_inode_header_1 inodep; - - if(msBlk->swap) { - squashfs_dev_inode_header_1 sinodep; - - if(!squashfs_get_cached_block(s, (char *) &sinodep, block, offset, sizeof(sinodep), - &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_DEV_INODE_HEADER_1(&inodep, &sinodep); - } else - if(!squashfs_get_cached_block(s, (char *) &inodep, block, offset, sizeof(inodep), - &next_block, &next_offset)) - goto failed_read; - - i->i_size = 0; - i->i_mode |= (inodeb.inode_type == SQUASHFS_CHRDEV_TYPE) ? S_IFCHR : S_IFBLK; - init_special_inode(i, i->i_mode, inodep.rdev); - TRACE("Device inode %x:%x, rdev %x\n", SQUASHFS_INODE_BLK(inode), offset, inodep.rdev); - break; - } - case SQUASHFS_IPC_TYPE: { - squashfs_ipc_inode_header_1 inodep; - - if(msBlk->swap) { - squashfs_ipc_inode_header_1 sinodep; - - if(!squashfs_get_cached_block(s, (char *) &sinodep, block, offset, sizeof(sinodep), - &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_IPC_INODE_HEADER_1(&inodep, &sinodep); - } else - if(!squashfs_get_cached_block(s, (char *) &inodep, block, offset, sizeof(inodep), - &next_block, &next_offset)) - goto failed_read; - - i->i_size = 0; - i->i_mode |= (inodep.type == SQUASHFS_FIFO_TYPE) ? S_IFIFO : S_IFSOCK; - i->i_uid = msBlk->uid[inodep.offset * 16 + inodeb.uid]; - init_special_inode(i, i->i_mode, 0); - break; - } - default: - ERROR("Unknown inode type %d in squashfs_iget!\n", inodeb.inode_type); - goto failed_read1; - } - - if(inodeb.guid == 15) - i->i_gid = i->i_uid; - else - i->i_gid = msBlk->guid[inodeb.guid]; - - return i; - -failed_read: - ERROR("Unable to read inode [%x:%x]\n", block, offset); - -failed_read1: - return NULL; -} -#endif - - -static struct inode *squashfs_iget(struct super_block *s, squashfs_inode inode) -{ - struct inode *i = new_inode(s); - squashfs_sb_info *msBlk = &s->u.squashfs_sb; - squashfs_super_block *sBlk = &msBlk->sBlk; - unsigned int block = SQUASHFS_INODE_BLK(inode) + sBlk->inode_table_start; - unsigned int offset = SQUASHFS_INODE_OFFSET(inode); - unsigned int next_block, next_offset; - squashfs_base_inode_header inodeb; - - TRACE("Entered squashfs_iget\n"); - - if(msBlk->swap) { - squashfs_base_inode_header sinodeb; - - if(!squashfs_get_cached_block(s, (char *) &sinodeb, block, offset, - sizeof(sinodeb), &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_BASE_INODE_HEADER(&inodeb, &sinodeb, sizeof(sinodeb)); - } else - if(!squashfs_get_cached_block(s, (char *) &inodeb, block, offset, - sizeof(inodeb), &next_block, &next_offset)) - goto failed_read; - - i->i_nlink = 1; - - i->i_mtime = sBlk->mkfs_time; - i->i_atime = sBlk->mkfs_time; - i->i_ctime = sBlk->mkfs_time; - - if(inodeb.inode_type != SQUASHFS_IPC_TYPE) - i->i_uid = msBlk->uid[((inodeb.inode_type - 1) / SQUASHFS_TYPES) * 16 + inodeb.uid]; - i->i_ino = SQUASHFS_MK_VFS_INODE(block - sBlk->inode_table_start, offset); - - i->i_mode = inodeb.mode; - - switch(inodeb.inode_type) { - case SQUASHFS_FILE_TYPE: { - squashfs_reg_inode_header inodep; - - if(msBlk->swap) { - squashfs_reg_inode_header sinodep; - - if(!squashfs_get_cached_block(s, (char *) &sinodep, block, offset, sizeof(sinodep), - &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_REG_INODE_HEADER(&inodep, &sinodep); - } else - if(!squashfs_get_cached_block(s, (char *) &inodep, block, offset, sizeof(inodep), - &next_block, &next_offset)) - goto failed_read; - - i->u.squashfs_i.fragment_start_block = SQUASHFS_INVALID_BLK; - if(inodep.fragment != SQUASHFS_INVALID_BLK && !get_fragment_location(s, inodep.fragment, - &i->u.squashfs_i.fragment_start_block, &i->u.squashfs_i.fragment_size)) - goto failed_read; - - i->u.squashfs_i.fragment_offset = inodep.offset; - i->i_size = inodep.file_size; - i->i_fop = &generic_ro_fops; - if(sBlk->block_size > 4096) - i->i_data.a_ops = &squashfs_aops; - else - i->i_data.a_ops = &squashfs_aops_4K; - i->i_mode |= S_IFREG; - i->i_mtime = inodep.mtime; - i->i_atime = inodep.mtime; - i->i_ctime = inodep.mtime; - i->i_blocks = ((i->i_size - 1) >> 9) + 1; - i->i_blksize = PAGE_CACHE_SIZE; - i->u.squashfs_i.start_block = inodep.start_block; - i->u.squashfs_i.block_list_start = next_block; - i->u.squashfs_i.offset = next_offset; - TRACE("File inode %x:%x, start_block %x, block_list_start %x, offset %x fragment_index %x fragment_offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, inodep.start_block, next_block, next_offset, inodep.fragment, inodep.offset); - break; - } - case SQUASHFS_DIR_TYPE: { - squashfs_dir_inode_header inodep; - - if(msBlk->swap) { - squashfs_dir_inode_header sinodep; - - if(!squashfs_get_cached_block(s, (char *) &sinodep, block, offset, sizeof(sinodep), - &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_DIR_INODE_HEADER(&inodep, &sinodep); - } else - if(!squashfs_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; - i->i_fop = &squashfs_dir_ops; - i->i_mode |= S_IFDIR; - i->i_mtime = inodep.mtime; - i->i_atime = inodep.mtime; - i->i_ctime = inodep.mtime; - i->u.squashfs_i.start_block = inodep.start_block; - i->u.squashfs_i.offset = inodep.offset; - TRACE("Directory inode %x:%x, start_block %x, offset %x\n", SQUASHFS_INODE_BLK(inode), offset, - inodep.start_block, inodep.offset); - break; - } - case SQUASHFS_SYMLINK_TYPE: { - squashfs_symlink_inode_header inodep; - - if(msBlk->swap) { - squashfs_symlink_inode_header sinodep; - - if(!squashfs_get_cached_block(s, (char *) &sinodep, block, offset, sizeof(sinodep), - &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_SYMLINK_INODE_HEADER(&inodep, &sinodep); - } else - if(!squashfs_get_cached_block(s, (char *) &inodep, block, offset, sizeof(inodep), - &next_block, &next_offset)) - goto failed_read; - - i->i_size = inodep.symlink_size; - i->i_op = &page_symlink_inode_operations; - i->i_data.a_ops = &squashfs_symlink_aops; - i->i_mode |= S_IFLNK; - i->u.squashfs_i.start_block = next_block; - i->u.squashfs_i.offset = next_offset; - TRACE("Symbolic link inode %x:%x, start_block %x, offset %x\n", - SQUASHFS_INODE_BLK(inode), offset, next_block, next_offset); - break; - } - case SQUASHFS_BLKDEV_TYPE: - case SQUASHFS_CHRDEV_TYPE: { - squashfs_dev_inode_header inodep; - - if(msBlk->swap) { - squashfs_dev_inode_header sinodep; - - if(!squashfs_get_cached_block(s, (char *) &sinodep, block, offset, sizeof(sinodep), - &next_block, &next_offset)) - goto failed_read; - SQUASHFS_SWAP_DEV_INODE_HEADER(&inodep, &sinodep); - } else - if(!squashfs_get_cached_block(s, (char *) &inodep, block, offset, sizeof(inodep), - &next_block, &next_offset)) - goto failed_read; - - i->i_size = 0; - i->i_mode |= (inodeb.inode_type == SQUASHFS_CHRDEV_TYPE) ? S_IFCHR : S_IFBLK; - init_special_inode(i, i->i_mode, inodep.rdev); - TRACE("Device inode %x:%x, rdev %x\n", SQUASHFS_INODE_BLK(inode), offset, inodep.rdev); - break; - } - case SQUASHFS_FIFO_TYPE: - case SQUASHFS_SOCKET_TYPE: { - i->i_size = 0; - i->i_mode |= (inodeb.inode_type == SQUASHFS_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", inodeb.inode_type); - goto failed_read1; - } - - if(inodeb.guid == SQUASHFS_GUIDS) - i->i_gid = i->i_uid; - else - i->i_gid = msBlk->guid[inodeb.guid]; - - return i; - -failed_read: - ERROR("Unable to read inode [%x:%x]\n", block, offset); - -failed_read1: - return NULL; -} - - -static struct super_block *squashfs_read_super(struct super_block *s, - void *data, int silent) -{ - kdev_t dev = s->s_dev; - squashfs_sb_info *msBlk = &s->u.squashfs_sb; - squashfs_super_block *sBlk = &msBlk->sBlk; - int i; - - TRACE("Entered squashfs_read_superblock\n"); - - msBlk->devblksize = get_hardsect_size(dev); - if(msBlk->devblksize < BLOCK_SIZE) - msBlk->devblksize = BLOCK_SIZE; - msBlk->devblksize_log2 = ffz(~msBlk->devblksize); - set_blocksize(dev, msBlk->devblksize); - s->s_blocksize = msBlk->devblksize; - s->s_blocksize_bits = msBlk->devblksize_log2; - - init_MUTEX(&msBlk->read_page_mutex); - init_MUTEX(&msBlk->block_cache_mutex); - init_MUTEX(&msBlk->fragment_mutex); - - init_waitqueue_head(&msBlk->waitq); - init_waitqueue_head(&msBlk->fragment_wait_queue); - - if(!read_data(s, (char *) sBlk, SQUASHFS_START, sizeof(squashfs_super_block) | SQUASHFS_COMPRESSED_BIT, 0, NULL)) { - SERROR("unable to read superblock\n"); - goto failed_mount; - } - - /* Check it is a SQUASHFS superblock */ - msBlk->swap = 0; - if((s->s_magic = sBlk->s_magic) != SQUASHFS_MAGIC) { - if(sBlk->s_magic == SQUASHFS_MAGIC_SWAP) { - squashfs_super_block sblk; - WARNING("Mounting a different endian SQUASHFS filesystem on %s\n", bdevname(dev)); - SQUASHFS_SWAP_SUPER_BLOCK(&sblk, sBlk); - memcpy(sBlk, &sblk, sizeof(squashfs_super_block)); - msBlk->swap = 1; - } else { - SERROR("Can't find a SQUASHFS superblock on %s\n", bdevname(dev)); - goto failed_mount; - } - } - - /* Check the MAJOR & MINOR versions */ -#ifdef SQUASHFS_1_0_COMPATIBILITY - if((sBlk->s_major != 1) && (sBlk->s_major != 2 || sBlk->s_minor > SQUASHFS_MINOR)) { - SERROR("Major/Minor mismatch, filesystem is (%d:%d), I support (1 : x) or (2 : <= %d)\n", - sBlk->s_major, sBlk->s_minor, SQUASHFS_MINOR); - goto failed_mount; - } - if(sBlk->s_major == 1) - sBlk->block_size = sBlk->block_size_1; -#else - if(sBlk->s_major != SQUASHFS_MAJOR || sBlk->s_minor > SQUASHFS_MINOR) { - SERROR("Major/Minor mismatch, filesystem is (%d:%d), I support (%d: <= %d)\n", - sBlk->s_major, sBlk->s_minor, SQUASHFS_MAJOR, SQUASHFS_MINOR); - goto failed_mount; - } -#endif - - TRACE("Found valid superblock on %s\n", bdevname(dev)); - TRACE("Inodes are %scompressed\n", SQUASHFS_UNCOMPRESSED_INODES(sBlk->flags) ? "un" : ""); - TRACE("Data is %scompressed\n", SQUASHFS_UNCOMPRESSED_DATA(sBlk->flags) ? "un" : ""); - TRACE("Check data is %s present in the filesystem\n", SQUASHFS_CHECK_DATA(sBlk->flags) ? "" : "not"); - TRACE("Filesystem size %d bytes\n", sBlk->bytes_used); - TRACE("Block size %d\n", sBlk->block_size); - TRACE("Number of inodes %d\n", sBlk->inodes); - if(sBlk->s_major > 1) - TRACE("Number of fragments %d\n", sBlk->fragments); - TRACE("Number of uids %d\n", sBlk->no_uids); - TRACE("Number of gids %d\n", sBlk->no_guids); - TRACE("sBlk->inode_table_start %x\n", sBlk->inode_table_start); - TRACE("sBlk->directory_table_start %x\n", sBlk->directory_table_start); - if(sBlk->s_major > 1) - TRACE("sBlk->fragment_table_start %x\n", sBlk->fragment_table_start); - TRACE("sBlk->uid_start %x\n", sBlk->uid_start); - - s->s_flags |= MS_RDONLY; - s->s_op = &squashfs_ops; - - /* Init inode_table block pointer array */ - if(!(msBlk->block_cache = (squashfs_cache *) kmalloc(sizeof(squashfs_cache) * SQUASHFS_CACHED_BLKS, GFP_KERNEL))) { - ERROR("Failed to allocate block cache\n"); - goto failed_mount; - } - - for(i = 0; i < SQUASHFS_CACHED_BLKS; i++) - msBlk->block_cache[i].block = SQUASHFS_INVALID_BLK; - - msBlk->next_cache = 0; - - /* Allocate read_data block */ - msBlk->read_size = (sBlk->block_size < SQUASHFS_METADATA_SIZE) ? SQUASHFS_METADATA_SIZE : sBlk->block_size; - if(!(msBlk->read_data = (char *) kmalloc(msBlk->read_size, GFP_KERNEL))) { - ERROR("Failed to allocate read_data block\n"); - goto failed_mount1; - } - - /* Allocate read_page block */ - if(sBlk->block_size > PAGE_CACHE_SIZE && - !(msBlk->read_page = (char *) kmalloc(sBlk->block_size, GFP_KERNEL))) { - ERROR("Failed to allocate read_page block\n"); - goto failed_mount2; - } - - /* Allocate uid and gid tables */ - if(!(msBlk->uid = (squashfs_uid *) kmalloc((sBlk->no_uids + - sBlk->no_guids) * sizeof(squashfs_uid), GFP_KERNEL))) { - ERROR("Failed to allocate uid/gid table\n"); - goto failed_mount3; - } - msBlk->guid = msBlk->uid + sBlk->no_uids; - - if(msBlk->swap) { - squashfs_uid suid[sBlk->no_uids + sBlk->no_guids]; - - if(!read_data(s, (char *) &suid, sBlk->uid_start, ((sBlk->no_uids + sBlk->no_guids) * - sizeof(squashfs_uid)) | SQUASHFS_COMPRESSED_BIT, 0, NULL)) { - SERROR("unable to read uid/gid table\n"); - goto failed_mount4; - } - SQUASHFS_SWAP_DATA(msBlk->uid, suid, (sBlk->no_uids + sBlk->no_guids), (sizeof(squashfs_uid) * 8)); - } else - if(!read_data(s, (char *) msBlk->uid, sBlk->uid_start, ((sBlk->no_uids + sBlk->no_guids) * - sizeof(squashfs_uid)) | SQUASHFS_COMPRESSED_BIT, 0, NULL)) { - SERROR("unable to read uid/gid table\n"); - goto failed_mount4; - } - - -#ifdef SQUASHFS_1_0_COMPATIBILITY - if(sBlk->s_major == 1) { - msBlk->iget = squashfs_iget_1; - msBlk->read_blocklist = read_blocklist_1; - msBlk->fragment = (struct squashfs_fragment_cache *) msBlk->fragment_index = NULL; - goto allocate_root; - } -#endif - msBlk->iget = squashfs_iget; - msBlk->read_blocklist = read_blocklist; - - if(!(msBlk->fragment = (struct squashfs_fragment_cache *) kmalloc(sizeof(struct squashfs_fragment_cache) * SQUASHFS_CACHED_FRAGMENTS, GFP_KERNEL))) { - ERROR("Failed to allocate fragment block cache\n"); - goto failed_mount4; - } - - for(i = 0; i < SQUASHFS_CACHED_FRAGMENTS; i++) { - msBlk->fragment[i].locked = 0; - msBlk->fragment[i].block = SQUASHFS_INVALID_BLK; - msBlk->fragment[i].data = NULL; - } - - msBlk->next_fragment = 0; - - /* Allocate fragment index table */ - if(!(msBlk->fragment_index = (squashfs_fragment_index *) kmalloc(SQUASHFS_FRAGMENT_INDEX_BYTES(sBlk->fragments), GFP_KERNEL))) { - ERROR("Failed to allocate uid/gid table\n"); - goto failed_mount5; - } - - if(SQUASHFS_FRAGMENT_INDEX_BYTES(sBlk->fragments) && - !read_data(s, (char *) msBlk->fragment_index, sBlk->fragment_table_start, - SQUASHFS_FRAGMENT_INDEX_BYTES(sBlk->fragments) | SQUASHFS_COMPRESSED_BIT, 0, NULL)) { - SERROR("unable to read fragment index table\n"); - goto failed_mount6; - } - - if(msBlk->swap) { - int i; - squashfs_fragment_index fragment; - - for(i = 0; i < SQUASHFS_FRAGMENT_INDEXES(sBlk->fragments); i++) { - SQUASHFS_SWAP_FRAGMENT_INDEXES((&fragment), &msBlk->fragment_index[i], 1); - msBlk->fragment_index[i] = fragment; - } - } - -#ifdef SQUASHFS_1_0_COMPATIBILITY -allocate_root: -#endif - if(!(s->s_root = d_alloc_root((msBlk->iget)(s, sBlk->root_inode)))) { - ERROR("Root inode create failed\n"); - goto failed_mount5; - } - - TRACE("Leaving squashfs_read_super\n"); - return s; - -failed_mount6: - kfree(msBlk->fragment_index); -failed_mount5: - kfree(msBlk->fragment); -failed_mount4: - kfree(msBlk->uid); -failed_mount3: - kfree(msBlk->read_page); -failed_mount2: - kfree(msBlk->read_data); -failed_mount1: - kfree(msBlk->block_cache); -failed_mount: - return NULL; -} - - -static int squashfs_statfs(struct super_block *s, struct statfs *buf) -{ - squashfs_super_block *sBlk = &s->u.squashfs_sb.sBlk; - - TRACE("Entered squashfs_statfs\n"); - buf->f_type = SQUASHFS_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; - return 0; -} - - -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; - int block = inode->u.squashfs_i.start_block; - int offset = inode->u.squashfs_i.offset; - void *pageaddr = kmap(page); - - TRACE("Entered squashfs_symlink_readpage, page index %x, start block %x, offset %x\n", - (unsigned int) page->index, inode->u.squashfs_i.start_block, inode->u.squashfs_i.offset); - - for(length = 0; length < index; length += bytes) { - if(!(bytes = squashfs_get_cached_block(inode->i_sb, NULL, block, offset, - PAGE_CACHE_SIZE, &block, &offset))) { - ERROR("Unable to read symbolic link [%x:%x]\n", block, offset); - goto skip_read; - } - } - - if(length != index) { - ERROR("(squashfs_symlink_readpage) length != index\n"); - bytes = 0; - goto skip_read; - } - - bytes = (inode->i_size - length) > PAGE_CACHE_SIZE ? PAGE_CACHE_SIZE : inode->i_size - length; - if(!(bytes = squashfs_get_cached_block(inode->i_sb, pageaddr, block, offset, bytes, &block, &offset))) - ERROR("Unable to read symbolic link [%x:%x]\n", block, offset); - -skip_read: - memset(pageaddr + bytes, 0, PAGE_CACHE_SIZE - bytes); - kunmap(page); - flush_dcache_page(page); - SetPageUptodate(page); - UnlockPage(page); - - return 0; -} - - -#define SIZE 256 - -#ifdef SQUASHFS_1_0_COMPATIBILITY -static unsigned int read_blocklist_1(struct inode *inode, int index, int readahead_blks, - char *block_list, char **block_p, unsigned int *bsize) -{ - squashfs_sb_info *msBlk = &inode->i_sb->u.squashfs_sb; - unsigned short *block_listp; - int i = 0; - int block_ptr = inode->u.squashfs_i.block_list_start; - int offset = inode->u.squashfs_i.offset; - int block = inode->u.squashfs_i.start_block; - - for(;;) { - int blocks = (index + readahead_blks - i); - if(blocks > (SIZE >> 1)) { - if((index - i) <= (SIZE >> 1)) - blocks = index - i; - else - blocks = SIZE >> 1; - } - - if(msBlk->swap) { - unsigned char sblock_list[SIZE]; - if(!squashfs_get_cached_block(inode->i_sb, (char *) sblock_list, block_ptr, offset, blocks << 1, &block_ptr, &offset)) { - ERROR("Unable to read block list [%d:%x]\n", block_ptr, offset); - return 0; - } - SQUASHFS_SWAP_SHORTS(((unsigned short *)block_list), ((unsigned short *)sblock_list), blocks); - } else - if(!squashfs_get_cached_block(inode->i_sb, (char *) block_list, block_ptr, offset, blocks << 1, &block_ptr, &offset)) { - ERROR("Unable to read block list [%d:%x]\n", block_ptr, offset); - return 0; - } - for(block_listp = (unsigned short *) block_list; i < index && blocks; i ++, block_listp ++, blocks --) - block += SQUASHFS_COMPRESSED_SIZE(*block_listp); - if(blocks >= readahead_blks) - break; - } - - if(bsize) - *bsize = SQUASHFS_COMPRESSED_SIZE(*block_listp) | (!SQUASHFS_COMPRESSED(*block_listp) ? SQUASHFS_COMPRESSED_BIT_BLOCK : 0); - else - (unsigned short *) *block_p = block_listp; - return block; -} -#endif - - - -static unsigned int read_blocklist(struct inode *inode, int index, int readahead_blks, - char *block_list, char **block_p, unsigned int *bsize) -{ - squashfs_sb_info *msBlk = &inode->i_sb->u.squashfs_sb; - unsigned int *block_listp; - int i = 0; - int block_ptr = inode->u.squashfs_i.block_list_start; - int offset = inode->u.squashfs_i.offset; - int block = inode->u.squashfs_i.start_block; - - for(;;) { - int blocks = (index + readahead_blks - i); - if(blocks > (SIZE >> 2)) { - if((index - i) <= (SIZE >> 2)) - blocks = index - i; - else - blocks = SIZE >> 2; - } - - if(msBlk->swap) { - unsigned char sblock_list[SIZE]; - if(!squashfs_get_cached_block(inode->i_sb, (char *) sblock_list, block_ptr, offset, blocks << 2, &block_ptr, &offset)) { - ERROR("Unable to read block list [%d:%x]\n", block_ptr, offset); - return 0; - } - SQUASHFS_SWAP_INTS(((unsigned int *)block_list), ((unsigned int *)sblock_list), blocks); - } else - if(!squashfs_get_cached_block(inode->i_sb, (char *) block_list, block_ptr, offset, blocks << 2, &block_ptr, &offset)) { - ERROR("Unable to read block list [%d:%x]\n", block_ptr, offset); - return 0; - } - for(block_listp = (unsigned int *) block_list; i < index && blocks; i ++, block_listp ++, blocks --) - block += SQUASHFS_COMPRESSED_SIZE_BLOCK(*block_listp); - if(blocks >= readahead_blks) - break; - } - - *bsize = *block_listp; - return block; -} - - -static int squashfs_readpage(struct file *file, struct page *page) -{ - struct inode *inode = page->mapping->host; - squashfs_sb_info *msBlk = &inode->i_sb->u.squashfs_sb; - squashfs_super_block *sBlk = &msBlk->sBlk; - unsigned char block_list[SIZE]; - unsigned int bsize, block, i = 0, bytes = 0, byte_offset = 0; - int index = page->index >> (sBlk->block_log - PAGE_CACHE_SHIFT); - void *pageaddr = kmap(page); - struct squashfs_fragment_cache *fragment; - char *data_ptr = msBlk->read_page; - - int mask = (1 << (sBlk->block_log - PAGE_CACHE_SHIFT)) - 1; - int start_index = page->index & ~mask; - int end_index = start_index | mask; - - TRACE("Entered squashfs_readpage, page index %x, start block %x\n", (unsigned int) page->index, - inode->u.squashfs_i.start_block); - - if(inode->u.squashfs_i.fragment_start_block == SQUASHFS_INVALID_BLK || index < (inode->i_size >> sBlk->block_log)) { - if((block = (msBlk->read_blocklist)(inode, index, 1, block_list, NULL, &bsize)) == 0) - goto skip_read; - - down(&msBlk->read_page_mutex); - if(!(bytes = read_data(inode->i_sb, msBlk->read_page, block, bsize, 1, NULL))) { - ERROR("Unable to read page, block %x, size %x\n", block, bsize); - up(&msBlk->read_page_mutex); - goto skip_read; - } - } else { - if((fragment = get_cached_fragment(inode->i_sb, inode->u.squashfs_i.fragment_start_block, inode->u.squashfs_i.fragment_size)) == NULL) { - ERROR("Unable to read page, block %x, size %x\n", inode->u.squashfs_i.fragment_start_block, (int) inode->u.squashfs_i.fragment_size); - goto skip_read; - } - bytes = inode->u.squashfs_i.fragment_offset + (inode->i_size & (sBlk->block_size - 1)); - byte_offset = inode->u.squashfs_i.fragment_offset; - data_ptr = fragment->data; - } - - for(i = start_index; i <= end_index && byte_offset < bytes; i++, byte_offset += PAGE_CACHE_SIZE) { - struct page *push_page; - int available_bytes = (bytes - byte_offset) > PAGE_CACHE_SIZE ? PAGE_CACHE_SIZE : bytes - byte_offset; - - TRACE("bytes %d, i %d, byte_offset %d, available_bytes %d\n", bytes, i, byte_offset, available_bytes); - - if(i == page->index) { - memcpy(pageaddr, data_ptr + byte_offset, available_bytes); - memset(pageaddr + available_bytes, 0, PAGE_CACHE_SIZE - available_bytes); - kunmap(page); - flush_dcache_page(page); - SetPageUptodate(page); - UnlockPage(page); - } else if((push_page = grab_cache_page_nowait(page->mapping, i))) { - void *pageaddr = kmap(push_page); - memcpy(pageaddr, data_ptr + byte_offset, available_bytes); - memset(pageaddr + available_bytes, 0, PAGE_CACHE_SIZE - available_bytes); - kunmap(push_page); - flush_dcache_page(push_page); - SetPageUptodate(push_page); - UnlockPage(push_page); - page_cache_release(push_page); - } - } - - if(inode->u.squashfs_i.fragment_start_block == SQUASHFS_INVALID_BLK || index < (inode->i_size >> sBlk->block_log)) - up(&msBlk->read_page_mutex); - else - release_cached_fragment(msBlk, fragment); - - return 0; - -skip_read: - memset(pageaddr + bytes, 0, PAGE_CACHE_SIZE - bytes); - kunmap(page); - flush_dcache_page(page); - SetPageUptodate(page); - UnlockPage(page); - - return 0; -} - - -static int squashfs_readpage4K(struct file *file, struct page *page) -{ - struct inode *inode = page->mapping->host; - squashfs_sb_info *msBlk = &inode->i_sb->u.squashfs_sb; - squashfs_super_block *sBlk = &msBlk->sBlk; - unsigned char block_list[SIZE]; - unsigned int bsize, block, bytes = 0; - void *pageaddr = kmap(page); - - TRACE("Entered squashfs_readpage4K, page index %x, start block %x\n", (unsigned int) page->index, - inode->u.squashfs_i.start_block); - - if(page->index < (inode->i_size >> sBlk->block_log)) { - block = (msBlk->read_blocklist)(inode, page->index, 1, block_list, NULL, &bsize); - - if(!(bytes = read_data(inode->i_sb, pageaddr, block, bsize, 1, NULL))) - ERROR("Unable to read page, block %x, size %x\n", block, bsize); - } else { - struct squashfs_fragment_cache *fragment; - - if((fragment = get_cached_fragment(inode->i_sb, inode->u.squashfs_i.fragment_start_block, inode->u.squashfs_i.fragment_size)) == NULL) - ERROR("Unable to read page, block %x, size %x\n", inode->u.squashfs_i.fragment_start_block, (int) inode->u.squashfs_i.fragment_size); - else { - bytes = inode->i_size & (sBlk->block_size - 1); - memcpy(pageaddr, fragment->data + inode->u.squashfs_i.fragment_offset, bytes); - release_cached_fragment(msBlk, fragment); - } - } - - memset(pageaddr + bytes, 0, PAGE_CACHE_SIZE - bytes); - kunmap(page); - flush_dcache_page(page); - SetPageUptodate(page); - UnlockPage(page); - - return 0; -} - - -#ifdef SQUASHFS_1_0_COMPATIBILITY -static int squashfs_readpage_lessthan4K(struct file *file, struct page *page) -{ - struct inode *inode = page->mapping->host; - squashfs_sb_info *msBlk = &inode->i_sb->u.squashfs_sb; - squashfs_super_block *sBlk = &msBlk->sBlk; - unsigned char block_list[SIZE]; - unsigned short *block_listp, block, bytes = 0; - int index = page->index << (PAGE_CACHE_SHIFT - sBlk->block_log); - int file_blocks = ((inode->i_size - 1) >> sBlk->block_log) + 1; - int readahead_blks = 1 << (PAGE_CACHE_SHIFT - sBlk->block_log); - void *pageaddr = kmap(page); - - int i_end = index + (1 << (PAGE_CACHE_SHIFT - sBlk->block_log)); - int byte; - - TRACE("Entered squashfs_readpage_lessthan4K, page index %x, start block %x\n", (unsigned int) page->index, - inode->u.squashfs_i.start_block); - - block = read_blocklist_1(inode, index, readahead_blks, block_list, (char **) &block_listp, NULL); - - if(i_end > file_blocks) - i_end = file_blocks; - - while(index < i_end) { - if(!(byte = read_data(inode->i_sb, pageaddr, block, *block_listp, 0, NULL))) { - ERROR("Unable to read page, block %x, size %x\n", block, *block_listp); - goto skip_read; - } - block += SQUASHFS_COMPRESSED_SIZE(*block_listp); - pageaddr += byte; - bytes += byte; - index ++; - block_listp ++; - } - -skip_read: - memset(pageaddr, 0, PAGE_CACHE_SIZE - bytes); - kunmap(page); - flush_dcache_page(page); - SetPageUptodate(page); - UnlockPage(page); - - return 0; -} -#endif - - -static int squashfs_readdir(struct file *file, void *dirent, filldir_t filldir) -{ - struct inode *i = file->f_dentry->d_inode; - squashfs_sb_info *msBlk = &i->i_sb->u.squashfs_sb; - squashfs_super_block *sBlk = &msBlk->sBlk; - int next_block = i->u.squashfs_i.start_block + sBlk->directory_table_start, next_offset = - i->u.squashfs_i.offset, length = 0, dirs_read = 0, dir_count; - squashfs_dir_header dirh; - char buffer[sizeof(squashfs_dir_entry) + SQUASHFS_NAME_LEN + 1]; - squashfs_dir_entry *dire = (squashfs_dir_entry *) buffer; - - TRACE("Entered squashfs_readdir [%x:%x]\n", next_block, next_offset); - - while(length < i->i_size) { - /* read directory header */ - if(msBlk->swap) { - squashfs_dir_header sdirh; - if(!squashfs_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(&dirh, &sdirh); - } else { - if(!squashfs_get_cached_block(i->i_sb, (char *) &dirh, next_block, - next_offset, sizeof(dirh), &next_block, &next_offset)) - goto failed_read; - length += sizeof(dirh); - } - - dir_count = dirh.count + 1; - while(dir_count--) { - if(msBlk->swap) { - squashfs_dir_entry sdire; - if(!squashfs_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(dire, &sdire); - } else { - if(!squashfs_get_cached_block(i->i_sb, (char *) 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, - next_offset, dire->size + 1, &next_block, &next_offset)) - goto failed_read; - length += dire->size + 1; - - if(file->f_pos >= length) - continue; - - dire->name[dire->size + 1] = '\0'; - - TRACE("Calling filldir(%x, %s, %d, %d, %x:%x, %d)\n", (unsigned int) dirent, - dire->name, dire->size + 1, (int) file->f_pos, - dirh.start_block, dire->offset, squashfs_filetype_table[dire->type]); - - if(filldir(dirent, dire->name, dire->size + 1, file->f_pos, SQUASHFS_MK_VFS_INODE(dirh.start_block, - dire->offset), squashfs_filetype_table[dire->type]) < 0) { - TRACE("Filldir returned less than 0\n"); - return dirs_read; - } - - file->f_pos = length; - dirs_read ++; - } - } - - return dirs_read; - -failed_read: - ERROR("Unable to read directory block [%x:%x]\n", next_block, next_offset); - return 0; -} - - -static struct dentry *squashfs_lookup(struct inode *i, struct dentry *dentry) -{ - const char *name =dentry->d_name.name; - int len = dentry->d_name.len; - struct inode *inode = NULL; - squashfs_sb_info *msBlk = &i->i_sb->u.squashfs_sb; - squashfs_super_block *sBlk = &msBlk->sBlk; - int next_block = i->u.squashfs_i.start_block + sBlk->directory_table_start, next_offset = - i->u.squashfs_i.offset, length = 0, dir_count; - squashfs_dir_header dirh; - char buffer[sizeof(squashfs_dir_entry) + SQUASHFS_NAME_LEN]; - squashfs_dir_entry *dire = (squashfs_dir_entry *) buffer; - - TRACE("Entered squashfs_lookup [%x:%x]\n", next_block, next_offset); - - while(length < i->i_size) { - /* read directory header */ - if(msBlk->swap) { - squashfs_dir_header sdirh; - if(!squashfs_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(&dirh, &sdirh); - } else { - if(!squashfs_get_cached_block(i->i_sb, (char *) &dirh, next_block, next_offset, - sizeof(dirh), &next_block, &next_offset)) - goto failed_read; - length += sizeof(dirh); - } - - dir_count = dirh.count + 1; - while(dir_count--) { - if(msBlk->swap) { - squashfs_dir_entry sdire; - if(!squashfs_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(dire, &sdire); - } else { - if(!squashfs_get_cached_block(i->i_sb, (char *) 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, next_offset, dire->size + 1, &next_block, &next_offset)) - goto failed_read; - length += dire->size + 1; - - if((len == dire->size + 1) && !strncmp(name, dire->name, len)) { - squashfs_inode ino = SQUASHFS_MKINODE(dirh.start_block, dire->offset); - - TRACE("calling squashfs_iget for directory entry %s, inode %x:%x\n", - name, dirh.start_block, dire->offset); - - inode = (msBlk->iget)(i->i_sb, ino); - - goto exit_loop; - } - } - } - -exit_loop: - d_add(dentry, inode); - return ERR_PTR(0); - -failed_read: - ERROR("Unable to read directory block [%x:%x]\n", next_block, next_offset); - goto exit_loop; -} - - -static void squashfs_put_super(struct super_block *s) -{ - if(s->u.squashfs_sb.block_cache) kfree(s->u.squashfs_sb.block_cache); - if(s->u.squashfs_sb.read_data) kfree(s->u.squashfs_sb.read_data); - if(s->u.squashfs_sb.read_page) kfree(s->u.squashfs_sb.read_page); - if(s->u.squashfs_sb.uid) kfree(s->u.squashfs_sb.uid); - s->u.squashfs_sb.block_cache = (void *) s->u.squashfs_sb.uid = - s->u.squashfs_sb.read_data = s->u.squashfs_sb.read_page = NULL; -} - - -static int __init init_squashfs_fs(void) -{ - - if(!(stream.workspace = (char *) vmalloc(zlib_inflate_workspacesize()))) { - ERROR("Failed to allocate zlib workspace\n"); - return -ENOMEM; - } - return register_filesystem(&squashfs_fs_type); -} - - -static void __exit exit_squashfs_fs(void) -{ - vfree(stream.workspace); - unregister_filesystem(&squashfs_fs_type); -} - - -EXPORT_NO_SYMBOLS; - -module_init(init_squashfs_fs); -module_exit(exit_squashfs_fs); -MODULE_DESCRIPTION("squashfs, a compressed read-only filesystem"); -MODULE_AUTHOR("Phillip Lougher "); -MODULE_LICENSE("GPL"); diff -ruN linux-2.4.20-WRTup/fs/squashfs/Makefile linux-2.4.20-WRTstp/fs/squashfs/Makefile --- linux-2.4.20-WRTup/fs/squashfs/Makefile 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/fs/squashfs/Makefile 1969-12-31 16:00:00.000000000 -0800 @@ -1,11 +0,0 @@ -# -# Makefile for the linux squashfs routines. -# - -O_TARGET := squashfs.o - -obj-y := inode.o - -obj-m := $(O_TARGET) - -include $(TOPDIR)/Rules.make diff -ruN linux-2.4.20-WRTup/include/linux/fs.h linux-2.4.20-WRTstp/include/linux/fs.h --- linux-2.4.20-WRTup/include/linux/fs.h 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/include/linux/fs.h 2005-11-08 06:24:51.000000000 -0800 @@ -320,7 +320,6 @@ #include #include #include -#include /* * Attribute flags. These should be or-ed together to figure out what @@ -511,7 +510,6 @@ struct socket socket_i; struct usbdev_inode_info usbdev_i; struct jffs2_inode_info jffs2_i; - struct squashfs_inode_info squashfs_i; void *generic_ip; } u; }; @@ -706,7 +704,6 @@ #include #include #include -#include extern struct list_head super_blocks; extern spinlock_t sb_lock; @@ -765,7 +762,6 @@ struct usbdev_sb_info usbdevfs_sb; struct jffs2_sb_info jffs2_sb; struct cramfs_sb_info cramfs_sb; - struct squashfs_sb_info squashfs_sb; void *generic_sbp; } u; /* diff -ruN linux-2.4.20-WRTup/include/linux/squashfs_fs.h linux-2.4.20-WRTstp/include/linux/squashfs_fs.h --- linux-2.4.20-WRTup/include/linux/squashfs_fs.h 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/include/linux/squashfs_fs.h 1969-12-31 16:00:00.000000000 -0800 @@ -1,474 +0,0 @@ -#ifndef SQUASHFS_FS -#define SQUASHFS_FS -/* - * Squashfs - * - * Copyright (c) 2002, 2003, 2004 Phillip Lougher - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2, - * or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * squashfs_fs.h - */ - -#define SQUASHFS_MAJOR 2 -#define SQUASHFS_MINOR 0 -#define SQUASHFS_MAGIC 0x73717368 -#define SQUASHFS_MAGIC_SWAP 0x68737173 -#define SQUASHFS_START 0 - -/* size of metadata (inode and directory) blocks */ -#define SQUASHFS_METADATA_SIZE 8192 -#define SQUASHFS_METADATA_LOG 13 - -/* default size of data blocks */ -#define SQUASHFS_FILE_SIZE 65536 -#define SQUASHFS_FILE_LOG 16 - -#define SQUASHFS_FILE_MAX_SIZE 65536 - -/* Max number of uids and gids */ -#define SQUASHFS_UIDS 256 -#define SQUASHFS_GUIDS 255 - -/* Max length of filename (not 255) */ -#define SQUASHFS_NAME_LEN 256 - -#define SQUASHFS_INVALID ((long long) 0xffffffffffff) -#define SQUASHFS_INVALID_BLK ((long long) 0xffffffff) -#define SQUASHFS_USED_BLK ((long long) 0xfffffffe) - -/* 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_BIT(flag, bit) ((flag >> bit) & 1) -#define SQUASHFS_UNCOMPRESSED_INODES(flags) SQUASHFS_BIT(flags, SQUASHFS_NOI) -#define SQUASHFS_UNCOMPRESSED_DATA(flags) SQUASHFS_BIT(flags, SQUASHFS_NOD) -#define SQUASHFS_UNCOMPRESSED_FRAGMENTS(flags) SQUASHFS_BIT(flags, SQUASHFS_NOF) -#define SQUASHFS_NO_FRAGMENTS(flags) SQUASHFS_BIT(flags, SQUASHFS_NO_FRAG) -#define SQUASHFS_ALWAYS_FRAGMENTS(flags) SQUASHFS_BIT(flags, SQUASHFS_ALWAYS_FRAG) -#define SQUASHFS_DUPLICATES(flags) SQUASHFS_BIT(flags, SQUASHFS_DUPLICATE) -#define SQUASHFS_CHECK_DATA(flags) SQUASHFS_BIT(flags, SQUASHFS_CHECK) -#define SQUASHFS_MKFLAGS(noi, nod, check_data, nof, no_frag, always_frag, duplicate_checking) (noi | (nod << 1) | (check_data << 2) | (nof << 3) | (no_frag << 4) | (always_frag << 5) | (duplicate_checking << 6)) - -/* 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 - -/* 1.0 filesystem type definitions */ -#define SQUASHFS_TYPES 5 -#define SQUASHFS_IPC_TYPE 0 - -/* Flag whether block is compressed or uncompressed, bit is set if block is uncompressed */ -#define SQUASHFS_COMPRESSED_BIT (1 << 15) -#define SQUASHFS_COMPRESSED_SIZE(B) (((B) & ~SQUASHFS_COMPRESSED_BIT) ? \ - (B) & ~SQUASHFS_COMPRESSED_BIT : SQUASHFS_COMPRESSED_BIT) - -#define SQUASHFS_COMPRESSED(B) (!((B) & SQUASHFS_COMPRESSED_BIT)) - -#define SQUASHFS_COMPRESSED_BIT_BLOCK (1 << 24) -#define SQUASHFS_COMPRESSED_SIZE_BLOCK(B) (((B) & ~SQUASHFS_COMPRESSED_BIT_BLOCK) ? \ - (B) & ~SQUASHFS_COMPRESSED_BIT_BLOCK : SQUASHFS_COMPRESSED_BIT_BLOCK) - -#define SQUASHFS_COMPRESSED_BLOCK(B) (!((B) & SQUASHFS_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 SQUASHFS_INODE_OFFSET(a) ((unsigned int) ((a) & 0xffff)) -#define SQUASHFS_MKINODE(A, B) ((squashfs_inode)(((squashfs_inode) (A) << 16)\ - + (B))) - -/* Compute 32 bit VFS inode number from squashfs inode number */ -#define SQUASHFS_MK_VFS_INODE(a, b) ((unsigned int) (((a) << 8) + ((b) >> 2) + 1)) - -/* Translate between VFS mode and squashfs mode */ -#define SQUASHFS_MODE(a) ((a) & 0xfff) - -/* fragment and fragment table defines */ -typedef unsigned int squashfs_fragment_index; -#define SQUASHFS_FRAGMENT_BYTES(A) (A * sizeof(squashfs_fragment_entry)) -#define SQUASHFS_FRAGMENT_INDEX(A) (SQUASHFS_FRAGMENT_BYTES(A) / SQUASHFS_METADATA_SIZE) -#define SQUASHFS_FRAGMENT_INDEX_OFFSET(A) (SQUASHFS_FRAGMENT_BYTES(A) % SQUASHFS_METADATA_SIZE) -#define SQUASHFS_FRAGMENT_INDEXES(A) ((SQUASHFS_FRAGMENT_BYTES(A) + SQUASHFS_METADATA_SIZE - 1) / SQUASHFS_METADATA_SIZE) -#define SQUASHFS_FRAGMENT_INDEX_BYTES(A) (SQUASHFS_FRAGMENT_INDEXES(A) * sizeof(squashfs_fragment_index)) -#define SQUASHFS_CACHED_FRAGMENTS 3 - -/* cached data constants for filesystem */ -#define SQUASHFS_CACHED_BLKS 8 - -#define SQUASHFS_MAX_FILE_SIZE_LOG 32 -#define SQUASHFS_MAX_FILE_SIZE ((long long) 1 << (SQUASHFS_MAX_FILE_SIZE_LOG - 1)) - -#define SQUASHFS_MARKER_BYTE 0xff - -/* - * definitions for structures on disk - */ - -typedef unsigned int squashfs_block; -typedef long long squashfs_inode; - -typedef unsigned int squashfs_uid; - -typedef struct squashfs_super_block { - unsigned int s_magic; - unsigned int inodes; - unsigned int bytes_used; - unsigned int uid_start; - unsigned int guid_start; - unsigned int inode_table_start; - unsigned int directory_table_start; - unsigned int s_major:16; - unsigned int s_minor:16; - unsigned int block_size_1:16; - unsigned int block_log:16; - unsigned int flags:8; - unsigned int no_uids:8; - unsigned int no_guids:8; - unsigned int mkfs_time /* time of filesystem creation */; - squashfs_inode root_inode; - unsigned int block_size; - unsigned int fragments; - unsigned int fragment_table_start; -} __attribute__ ((packed)) squashfs_super_block; - -typedef struct { - 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)) squashfs_base_inode_header; - -typedef squashfs_base_inode_header squashfs_ipc_inode_header; - -typedef struct { - 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 */ - unsigned short rdev; -} __attribute__ ((packed)) squashfs_dev_inode_header; - -typedef struct { - 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 */ - unsigned short symlink_size; - char symlink[0]; -} __attribute__ ((packed)) squashfs_symlink_inode_header; - -typedef struct { - 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 */ - unsigned int mtime; - squashfs_block start_block; - unsigned int fragment; - unsigned int offset; - unsigned int file_size:SQUASHFS_MAX_FILE_SIZE_LOG; - unsigned short block_list[0]; -} __attribute__ ((packed)) squashfs_reg_inode_header; - -typedef struct { - 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 */ - unsigned int file_size:19; - unsigned int offset:13; - unsigned int mtime; - unsigned int start_block:24; -} __attribute__ ((packed)) squashfs_dir_inode_header; - -typedef union { - squashfs_base_inode_header base; - squashfs_dev_inode_header dev; - squashfs_symlink_inode_header symlink; - squashfs_reg_inode_header reg; - squashfs_dir_inode_header dir; - squashfs_ipc_inode_header ipc; -} squashfs_inode_header; - -typedef struct { - unsigned int offset:13; - unsigned int type:3; - unsigned int size:8; - char name[0]; -} __attribute__ ((packed)) squashfs_dir_entry; - -typedef struct { - unsigned int count:8; - unsigned int start_block:24; -} __attribute__ ((packed)) squashfs_dir_header; - - -typedef struct { - unsigned int start_block; - unsigned int size; -} __attribute__ ((packed)) squashfs_fragment_entry; - -extern int squashfs_uncompress_block(void *d, int dstlen, void *s, int srclen); -extern int squashfs_uncompress_init(void); -extern int squashfs_uncompress_exit(void); - -/* - * macros to convert each packed bitfield structure from little endian to big - * endian and vice versa. These are needed when creating or using a filesystem on a - * machine with different byte ordering to the target architecture. - * - */ - -#define SQUASHFS_SWAP_SUPER_BLOCK(s, d) {\ - SQUASHFS_MEMSET(s, d, sizeof(squashfs_super_block));\ - SQUASHFS_SWAP((s)->s_magic, d, 0, 32);\ - SQUASHFS_SWAP((s)->inodes, d, 32, 32);\ - SQUASHFS_SWAP((s)->bytes_used, d, 64, 32);\ - SQUASHFS_SWAP((s)->uid_start, d, 96, 32);\ - SQUASHFS_SWAP((s)->guid_start, d, 128, 32);\ - SQUASHFS_SWAP((s)->inode_table_start, d, 160, 32);\ - SQUASHFS_SWAP((s)->directory_table_start, 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, d, 472, 32);\ -} - -#define SQUASHFS_SWAP_BASE_INODE_HEADER(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 SQUASHFS_SWAP_IPC_INODE_HEADER(s, d) SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_ipc_inode_header)) - -#define SQUASHFS_SWAP_DEV_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_dev_inode_header));\ - SQUASHFS_SWAP((s)->rdev, d, 32, 16);\ -} - -#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_symlink_inode_header));\ - SQUASHFS_SWAP((s)->symlink_size, d, 32, 16);\ -} - -#define SQUASHFS_SWAP_REG_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_reg_inode_header));\ - 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, SQUASHFS_MAX_FILE_SIZE_LOG);\ -} - -#define SQUASHFS_SWAP_DIR_INODE_HEADER(s, d) {\ - SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_dir_inode_header));\ - 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 SQUASHFS_SWAP_DIR_HEADER(s, d) {\ - SQUASHFS_MEMSET(s, d, sizeof(squashfs_dir_header));\ - SQUASHFS_SWAP((s)->count, d, 0, 8);\ - SQUASHFS_SWAP((s)->start_block, d, 8, 24);\ -} - -#define SQUASHFS_SWAP_DIR_ENTRY(s, d) {\ - SQUASHFS_MEMSET(s, d, sizeof(squashfs_dir_entry));\ - SQUASHFS_SWAP((s)->offset, d, 0, 13);\ - SQUASHFS_SWAP((s)->type, d, 13, 3);\ - SQUASHFS_SWAP((s)->size, d, 16, 8);\ -} - -#define SQUASHFS_SWAP_FRAGMENT_ENTRY(s, d) {\ - SQUASHFS_MEMSET(s, d, sizeof(squashfs_fragment_entry));\ - SQUASHFS_SWAP((s)->start_block, d, 0, 32);\ - SQUASHFS_SWAP((s)->size, d, 32, 32);\ -} - -#define SQUASHFS_SWAP_SHORTS(s, d, n) {\ - int entry;\ - int bit_position;\ - SQUASHFS_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);\ -} - -#define SQUASHFS_SWAP_INTS(s, d, n) {\ - int entry;\ - int bit_position;\ - SQUASHFS_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);\ -} - -#define SQUASHFS_SWAP_DATA(s, d, n, bits) {\ - int entry;\ - int bit_position;\ - SQUASHFS_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);\ -} - -#define SQUASHFS_SWAP_FRAGMENT_INDEXES(s, d, n) SQUASHFS_SWAP_INTS(s, d, n) - -#ifdef SQUASHFS_1_0_COMPATIBILITY -typedef struct { - 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)) squashfs_base_inode_header_1; - -typedef struct { - 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 */ - unsigned int type:4; - unsigned int offset:4; -} __attribute__ ((packed)) squashfs_ipc_inode_header_1; - -typedef struct { - 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 */ - unsigned short rdev; -} __attribute__ ((packed)) squashfs_dev_inode_header_1; - -typedef struct { - 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 */ - unsigned short symlink_size; - char symlink[0]; -} __attribute__ ((packed)) squashfs_symlink_inode_header_1; - -typedef struct { - 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 */ - unsigned int mtime; - squashfs_block start_block; - unsigned int file_size:SQUASHFS_MAX_FILE_SIZE_LOG; - unsigned short block_list[0]; -} __attribute__ ((packed)) squashfs_reg_inode_header_1; - -typedef struct { - 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 */ - unsigned int file_size:19; - unsigned int offset:13; - unsigned int mtime; - unsigned int start_block:24; -} __attribute__ ((packed)) squashfs_dir_inode_header_1; - -#define SQUASHFS_SWAP_BASE_INODE_HEADER_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 SQUASHFS_SWAP_IPC_INODE_HEADER_1(s, d) {\ - SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, sizeof(squashfs_ipc_inode_header_1));\ - SQUASHFS_SWAP((s)->type, d, 24, 4);\ - SQUASHFS_SWAP((s)->offset, d, 28, 4);\ -} - -#define SQUASHFS_SWAP_DEV_INODE_HEADER_1(s, d) {\ - SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, sizeof(squashfs_dev_inode_header_1));\ - SQUASHFS_SWAP((s)->rdev, d, 24, 16);\ -} - -#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(s, d) {\ - SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(squashfs_symlink_inode_header_1));\ - SQUASHFS_SWAP((s)->symlink_size, d, 24, 16);\ -} - -#define SQUASHFS_SWAP_REG_INODE_HEADER_1(s, d) {\ - SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(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, SQUASHFS_MAX_FILE_SIZE_LOG);\ -} - -#define SQUASHFS_SWAP_DIR_INODE_HEADER_1(s, d) {\ - SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, sizeof(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);\ -} -#endif - -#ifdef __KERNEL__ -/* - * macros used to swap each structure entry, taking into account - * bitfields and different bitfield placing conventions on differing architectures - */ -#include -#ifdef __BIG_ENDIAN - /* convert from little endian to big endian */ -#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_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, tbits, 64 - tbits - b_pos) -#endif - -#define _SQUASHFS_SWAP(value, p, pos, tbits, SHIFT) {\ - int bits;\ - int b_pos = pos % 8;\ - unsigned long long val = 0;\ - unsigned char *s = (unsigned char *)p + (pos / 8);\ - unsigned char *d = ((unsigned char *) &val) + 7;\ - for(bits = 0; bits < (tbits + b_pos); bits += 8) \ - *d-- = *s++;\ - value = (val >> (SHIFT))/* & ((1 << tbits) - 1)*/;\ -} -#define SQUASHFS_MEMSET(s, d, n) memset(s, 0, n); -#endif -#endif diff -ruN linux-2.4.20-WRTup/include/linux/squashfs_fs_i.h linux-2.4.20-WRTstp/include/linux/squashfs_fs_i.h --- linux-2.4.20-WRTup/include/linux/squashfs_fs_i.h 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/include/linux/squashfs_fs_i.h 1969-12-31 16:00:00.000000000 -0800 @@ -1,33 +0,0 @@ -#ifndef SQUASHFS_FS_I -#define SQUASHFS_FS_I -/* - * Squashfs - * - * Copyright (c) 2002, 2003, 2004 Phillip Lougher - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2, - * or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * squashfs_fs_i.h - */ - -typedef struct squashfs_inode_info { - unsigned int start_block; - unsigned int block_list_start; - unsigned int offset; - unsigned int fragment_start_block; - unsigned int fragment_size; - unsigned int fragment_offset; - } squashfs_inode_info; -#endif diff -ruN linux-2.4.20-WRTup/include/linux/squashfs_fs_sb.h linux-2.4.20-WRTstp/include/linux/squashfs_fs_sb.h --- linux-2.4.20-WRTup/include/linux/squashfs_fs_sb.h 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/include/linux/squashfs_fs_sb.h 1969-12-31 16:00:00.000000000 -0800 @@ -1,65 +0,0 @@ -#ifndef SQUASHFS_FS_SB -#define SQUASHFS_FS_SB -/* - * Squashfs - * - * Copyright (c) 2002, 2003, 2004 Phillip Lougher - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2, - * or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * squashfs_fs_sb.h - */ - -#include - -typedef struct { - unsigned int block; - int length; - unsigned int next_index; - char *data; - } squashfs_cache; - -struct squashfs_fragment_cache { - unsigned int block; - int length; - unsigned int locked; - char *data; - }; - -typedef struct squashfs_sb_info { - squashfs_super_block sBlk; - int devblksize; - int devblksize_log2; - int swap; - squashfs_cache *block_cache; - struct squashfs_fragment_cache *fragment; - int next_cache; - int next_fragment; - squashfs_uid *uid; - squashfs_uid *guid; - squashfs_fragment_index *fragment_index; - unsigned int read_size; - char *read_data; - char *read_page; - struct semaphore read_page_mutex; - struct semaphore block_cache_mutex; - struct semaphore fragment_mutex; - wait_queue_head_t waitq; - wait_queue_head_t fragment_wait_queue; - struct inode *(*iget)(struct super_block *s, squashfs_inode inode); - unsigned int (*read_blocklist)(struct inode *inode, int index, int readahead_blks, - char *block_list, char **block_p, unsigned int *bsize); - } squashfs_sb_info; -#endif diff -ruN linux-2.4.20-WRTup/init/do_mounts.c linux-2.4.20-WRTstp/init/do_mounts.c --- linux-2.4.20-WRTup/init/do_mounts.c 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/init/do_mounts.c 2005-11-08 06:24:53.000000000 -0800 @@ -15,7 +15,6 @@ #include #include #include -#include #define BUILD_CRAMDISK @@ -461,7 +460,6 @@ * ext2 * romfs * gzip - * squashfs */ static int __init identify_ramdisk_image(int fd, int start_block) @@ -470,7 +468,6 @@ struct minix_super_block *minixsb; struct ext2_super_block *ext2sb; struct romfs_super_block *romfsb; - struct squashfs_super_block *squashfsb; int nblocks = -1; unsigned char *buf; @@ -481,7 +478,6 @@ minixsb = (struct minix_super_block *) buf; ext2sb = (struct ext2_super_block *) buf; romfsb = (struct romfs_super_block *) buf; - squashfsb = (struct squashfs_super_block *) buf; memset(buf, 0xe5, size); /* @@ -511,15 +507,6 @@ goto done; } - /* squashfs is at block zero too */ - if (squashfsb->s_magic == SQUASHFS_MAGIC) { - printk(KERN_NOTICE - "RAMDISK: squashfs filesystem found at block %d\n", - start_block); - nblocks = (squashfsb->bytes_used+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS; - goto done; - } - /* * Read block 1 to test for minix and ext2 superblock */ diff -ruN linux-2.4.20-WRTup/lib/Config.in linux-2.4.20-WRTstp/lib/Config.in --- linux-2.4.20-WRTup/lib/Config.in 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/lib/Config.in 2005-11-08 06:24:53.000000000 -0800 @@ -8,14 +8,12 @@ # Do we need the compression support? # if [ "$CONFIG_CRAMFS" = "y" -o \ - "$CONFIG_SQUASHFS" = "y" -o \ "$CONFIG_PPP_DEFLATE" = "y" -o \ "$CONFIG_JFFS2_FS" = "y" -o \ "$CONFIG_ZISOFS_FS" = "y" ]; then define_tristate CONFIG_ZLIB_INFLATE y else if [ "$CONFIG_CRAMFS" = "m" -o \ - "$CONFIG_SQUASHFS" = "m" -o \ "$CONFIG_PPP_DEFLATE" = "m" -o \ "$CONFIG_JFFS2_FS" = "m" -o \ "$CONFIG_ZISOFS_FS" = "m" ]; then diff -ruN linux-2.4.20-WRTup/scripts/squashfs/Makefile linux-2.4.20-WRTstp/scripts/squashfs/Makefile --- linux-2.4.20-WRTup/scripts/squashfs/Makefile 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/scripts/squashfs/Makefile 1969-12-31 16:00:00.000000000 -0800 @@ -1,17 +0,0 @@ -INCLUDEDIR = . - -CC=gcc - -CFLAGS := -I$(INCLUDEDIR) -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -O2 - -mksquashfs: mksquashfs.o read_fs.o sort.o - $(CC) mksquashfs.o read_fs.o sort.o -lz -o $@ - -mksquashfs.o: mksquashfs.c mksquashfs.h - -read_fs.o: read_fs.c read_fs.h - -sort.o: sort.c - -clean: - rm -f *.o mksquashfs diff -ruN linux-2.4.20-WRTup/scripts/squashfs/mksquashfs.c linux-2.4.20-WRTstp/scripts/squashfs/mksquashfs.c --- linux-2.4.20-WRTup/scripts/squashfs/mksquashfs.c 2006-06-12 17:47:32.000000000 -0700 +++ linux-2.4.20-WRTstp/scripts/squashfs/mksquashfs.c 1969-12-31 16:00:00.000000000 -0800 @@ -1,1908 +0,0 @@ -/* - * Create a squashfs filesystem. This is a highly compressed read only filesystem. - * - * Copyright (c) 2002, 2003, 2004 Phillip Lougher - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2, - * or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * mksquashfs.c - */ - -#define TRUE 1 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "mksquashfs.h" -#include - -#ifdef SQUASHFS_TRACE -#define TRACE(s, args...) printf("mksquashfs: "s, ## args) -#else -#define TRACE(s, args...) -#endif - -#define INFO(s, args...) do { if(!silent) printf("mksquashfs: "s, ## args); } while(0) -#define ERROR(s, args...) do { fprintf(stderr, s, ## args); } while(0) -#define EXIT_MKSQUASHFS() do { if(restore)\ - restorefs();\ - exit(1); } while(0) -#define BAD_ERROR(s, args...) do {\ - fprintf(stderr, "FATAL ERROR:" s, ##args);\ - EXIT_MKSQUASHFS();\ - } while(0) - -int duplicate_checking = 1, noF = 0, no_fragments = 0, always_use_fragments = 0; -int total_compressed = 0, total_uncompressed = 0; - -int fd; - -/* superblock attributes */ -int noI = 0, noD = 0, check_data = 0, block_size = SQUASHFS_FILE_SIZE, block_log; -unsigned short uid_count = 0, guid_count = 0; -squashfs_uid uids[SQUASHFS_UIDS], guids[SQUASHFS_GUIDS]; -int block_offset; - -/* write position within data section */ -unsigned int bytes = 0, total_bytes = 0; - -/* in memory directory table - possibly compressed */ -char *directory_table = NULL; -unsigned int directory_bytes = 0, directory_size = 0, total_directory_bytes = 0; - -/* cached directory table */ -char *directory_data_cache = NULL; -unsigned int directory_cache_bytes = 0, directory_cache_size = 0; - -/* in memory inode table - possibly compressed */ -char *inode_table = NULL; -unsigned int inode_bytes = 0, inode_size = 0, total_inode_bytes = 0; - -/* cached inode table */ -char *data_cache = NULL; -unsigned int cache_bytes = 0, cache_size = 0, inode_count = 0; - -/* in memory directory header */ -struct directory { - unsigned int start_block; - unsigned int size; - unsigned char *buff; - unsigned char *p; - unsigned int entry_count; - squashfs_dir_header *entry_count_p; -}; - -struct file_info *dupl[65536], *frag_dups[65536]; -int dup_files = 0; - -int swap, silent = TRUE; -int file_count = 0, sym_count = 0, dev_count = 0, dir_count = 0, fifo_count = 0, sock_count = 0; - -/* list of exclude dirs/files */ -struct exclude_info { - dev_t st_dev; - ino_t st_ino; -}; - -#define EXCLUDE_SIZE 8192 -int exclude = 0; -struct exclude_info *exclude_paths = NULL; -int excluded(char *filename, struct stat *buf); - -/* fragment block data structures */ -int fragments = 0; -static char *fragment_data; -static int fragment_size = 0; -struct fragment { - unsigned int index; - int offset; - int size; -}; - - -#define FRAG_SIZE 32768 -squashfs_fragment_entry *fragment_table = NULL; - -/* list of source dirs/files */ -int source = 0; -char **source_path; - -/* list of root directory entries read from original filesystem */ -int old_root_entries = 0; -struct old_root_entry_info { - char name[SQUASHFS_NAME_LEN + 1]; - squashfs_inode inode; - int type; -}; - -/* in memory file info */ -struct file_info { - unsigned int bytes; - unsigned short checksum; - unsigned int start; - unsigned int *block_list; - struct file_info *next; - struct fragment *fragment; - unsigned short fragment_checksum; -}; - -/* count of how many times SIGINT or SIGQUIT has been sent */ -int interrupted = 0; - -/* restore orignal filesystem state if appending to existing filesystem is cancelled */ -jmp_buf env; -char *sdata_cache, *sdirectory_data_cache; -unsigned int sbytes, sinode_bytes, scache_bytes, sdirectory_bytes, - sdirectory_cache_bytes, suid_count, sguid_count, - stotal_bytes, stotal_inode_bytes, stotal_directory_bytes, - sinode_count, sfile_count, ssym_count, sdev_count, - sdir_count, sdup_files; -int sfragments; -int restore = 0; - -/*flag whether destination file is a block device */ -int block_device = 0; - -/* flag indicating whether files are sorted using sort list(s) */ -int sorted = 0; - -long long global_uid = -1, global_gid = -1; - -/* structure to used to pass in a pointer or an integer - * to duplicate buffer read helper functions. - */ -struct duplicate_buffer_handle { - unsigned char *ptr; - unsigned int start; -}; - -struct old_root_entry_info *old_root_entry; -void add_old_root_entry(char *name, squashfs_inode inode, int type); -extern int read_super(int fd, squashfs_super_block *sBlk, int *be, char *source); -extern int read_filesystem(char *root_name, int fd, squashfs_super_block *sBlk, char **inode_table, int *inode_bytes, - char **data_cache, int *cache_bytes, int *cache_size, char **directory_table, int *directory_bytes, - char **directory_data_cache, int *directory_cache_bytes, int *directory_cache_size, - int *file_count, int *sym_count, int *dev_count, int *dir_count, int *fifo_count, int *sock_count, - squashfs_uid *uids, unsigned short *uid_count, squashfs_uid *guids, unsigned short *guid_count, - unsigned int *uncompressed_file, unsigned int *uncompressed_inode, unsigned int *uncompressed_directory, - void (push_directory_entry)(char *, squashfs_inode, int), squashfs_fragment_entry **fragment_table); -squashfs_inode get_sorted_inode(struct stat *buf); -int read_sort_file(char *filename, int source, char *source_path[]); -void sort_files_and_write(int source, char *source_path[]); -struct file_info *duplicate(unsigned char *(get_next_file_block)(struct duplicate_buffer_handle *, unsigned int), struct duplicate_buffer_handle *file_start, int bytes, unsigned int **block_list, int *start, int blocks, struct fragment **fragment, char *frag_data, int frag_bytes); - -#define FALSE 0 - -#define MKINODE(A) ((squashfs_inode)(((squashfs_inode) inode_bytes << 16) + (((char *)A) - data_cache))) - - -void restorefs() -{ - ERROR("Exiting - restoring original filesystem!\n\n"); - bytes = sbytes; - memcpy(data_cache, sdata_cache, cache_bytes = scache_bytes); - memcpy(directory_data_cache, sdirectory_data_cache, directory_cache_bytes = sdirectory_cache_bytes); - inode_bytes = sinode_bytes; - directory_bytes = sdirectory_bytes; - uid_count = suid_count; - guid_count = sguid_count; - total_bytes = stotal_bytes; - total_inode_bytes = stotal_inode_bytes; - total_directory_bytes = stotal_directory_bytes; - inode_count = sinode_count; - file_count = sfile_count; - sym_count = ssym_count; - dev_count = sdev_count; - dir_count = sdir_count; - dup_files = sdup_files; - fragments = sfragments; - fragment_size = 0; - longjmp(env, 1); -} - - -void sighandler() -{ - if(interrupted == 1) - restorefs(); - else { - ERROR("Interrupting will restore original filesystem!\n"); - ERROR("Interrupt again to quit\n"); - interrupted ++; - } -} - - -unsigned int mangle(char *d, char *s, int size, int block_size, int uncompressed, int data_block) -{ - unsigned long c_byte = block_size << 1; - unsigned int res; - - if(!uncompressed && (res = compress2(d, &c_byte, s, size, 9)) != Z_OK) { - if(res == Z_MEM_ERROR) - BAD_ERROR("zlib::compress failed, not enough memory\n"); - else if(res == Z_BUF_ERROR) - BAD_ERROR("zlib::compress failed, not enough room in output buffer\n"); - else - BAD_ERROR("zlib::compress failed, unknown error %d\n", res); - return 0; - } - - if(uncompressed || c_byte >= size) { - memcpy(d, s, size); - return size | (data_block ? SQUASHFS_COMPRESSED_BIT_BLOCK : SQUASHFS_COMPRESSED_BIT); - } - - return (unsigned int) c_byte; -} - - -squashfs_base_inode_header *get_inode(int req_size) -{ - int data_space; - unsigned short c_byte; - - while(cache_bytes >= SQUASHFS_METADATA_SIZE) { - if((inode_size - inode_bytes) < ((SQUASHFS_METADATA_SIZE << 1)) + 2) { - if((inode_table = (char *) realloc(inode_table, inode_size + (SQUASHFS_METADATA_SIZE << 1) + 2)) - == NULL) { - goto failed; - } - inode_size += (SQUASHFS_METADATA_SIZE << 1) + 2; - } - - c_byte = mangle(inode_table + inode_bytes + block_offset, data_cache, - SQUASHFS_METADATA_SIZE, SQUASHFS_METADATA_SIZE, noI, 0); - TRACE("Inode block @ %x, size %d\n", inode_bytes, c_byte); - if(!swap) - memcpy((void *) (inode_table + inode_bytes), (void *) &c_byte, sizeof(unsigned short)); - else - SQUASHFS_SWAP_SHORTS((&c_byte), (inode_table + inode_bytes), 1); - if(check_data) - *((unsigned char *)(inode_table + inode_bytes + block_offset - 1)) = SQUASHFS_MARKER_BYTE; - inode_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + block_offset; - total_inode_bytes += SQUASHFS_METADATA_SIZE + block_offset; - memcpy(data_cache, data_cache + SQUASHFS_METADATA_SIZE, cache_bytes - SQUASHFS_METADATA_SIZE); - cache_bytes -= SQUASHFS_METADATA_SIZE; - } - - data_space = (cache_size - cache_bytes); - if(data_space < req_size) { - int realloc_size = cache_size == 0 ? ((req_size + SQUASHFS_METADATA_SIZE) & ~(SQUASHFS_METADATA_SIZE - 1)) : req_size - data_space; - - if((data_cache = (char *) realloc(data_cache, cache_size + realloc_size)) == NULL) { - goto failed; - } - cache_size += realloc_size; - } - - cache_bytes += req_size; - - return (squashfs_base_inode_header *)(data_cache + (cache_bytes - req_size)); - -failed: - BAD_ERROR("Out of memory in inode table reallocation!\n"); -} - - -void read_bytes(int fd, unsigned int byte, int bytes, char *buff) -{ - off_t off = byte; - - if(lseek(fd, off, SEEK_SET) == -1) { - perror("Lseek on destination failed"); - EXIT_MKSQUASHFS(); - } - - if(read(fd, buff, bytes) == -1) { - perror("Read on destination failed"); - EXIT_MKSQUASHFS(); - } -} - - -void write_bytes(int fd, unsigned int byte, int bytes, char *buff) -{ - off_t off = byte; - - if(off + bytes > ((long long)1<<32) - 1 ) - BAD_ERROR("Filesystem greater than maximum size 2^32 - 1\n"); - - if(lseek(fd, off, SEEK_SET) == -1) { - perror("Lseek on destination failed"); - EXIT_MKSQUASHFS(); - } - - if(write(fd, buff, bytes) == -1) { - perror("Write on destination failed"); - EXIT_MKSQUASHFS(); - } -} - - -unsigned int write_inodes() -{ - unsigned short c_byte; - int avail_bytes; - char *datap = data_cache; - unsigned int start_bytes = bytes; - - while(cache_bytes) { - if(inode_size - inode_bytes < ((SQUASHFS_METADATA_SIZE << 1) + 2)) { - if((inode_table = (char *) realloc(inode_table, inode_size + ((SQUASHFS_METADATA_SIZE << 1) + 2))) == NULL) { - BAD_ERROR("Out of memory in inode table reallocation!\n"); - } - inode_size += (SQUASHFS_METADATA_SIZE << 1) + 2; - } - avail_bytes = cache_bytes > SQUASHFS_METADATA_SIZE ? SQUASHFS_METADATA_SIZE : cache_bytes; - c_byte = mangle(inode_table + inode_bytes + block_offset, datap, avail_bytes, SQUASHFS_METADATA_SIZE, noI, 0); - TRACE("Inode block @ %x, size %d\n", inode_bytes, c_byte); - if(!swap) - memcpy((void *) (inode_table + inode_bytes), (void *) &c_byte, sizeof(unsigned short)); - else - SQUASHFS_SWAP_SHORTS((&c_byte), (inode_table + inode_bytes), 1); - if(check_data) - *((unsigned char *)(inode_table + inode_bytes + block_offset - 1)) = SQUASHFS_MARKER_BYTE; - inode_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + block_offset; - total_inode_bytes += avail_bytes + block_offset; - datap += avail_bytes; - cache_bytes -= avail_bytes; - } - - write_bytes(fd, bytes, inode_bytes, (char *) inode_table); - bytes += inode_bytes; - - return start_bytes; -} - - -unsigned int write_directories() -{ - unsigned short c_byte; - int avail_bytes; - char *directoryp = directory_data_cache; - unsigned int start_bytes = bytes; - - while(directory_cache_bytes) { - if(directory_size - directory_bytes < ((SQUASHFS_METADATA_SIZE << 1) + 2)) { - if((directory_table = (char *) realloc(directory_table, directory_size + - ((SQUASHFS_METADATA_SIZE << 1) + 2))) == NULL) { - BAD_ERROR("Out of memory in directory table reallocation!\n"); - } - directory_size += (SQUASHFS_METADATA_SIZE << 1) + 2; - } - avail_bytes = directory_cache_bytes > SQUASHFS_METADATA_SIZE ? SQUASHFS_METADATA_SIZE : directory_cache_bytes; - c_byte = mangle(directory_table + directory_bytes + block_offset, directoryp, avail_bytes, SQUASHFS_METADATA_SIZE, noI, 0); - TRACE("Directory block @ %x, size %d\n", directory_bytes, c_byte); - if(!swap) - memcpy((void *) (directory_table + directory_bytes), (void *) &c_byte, sizeof(unsigned short)); - else - SQUASHFS_SWAP_SHORTS((&c_byte), (directory_table + directory_bytes), 1); - if(check_data) - *((unsigned char *)(directory_table + directory_bytes + block_offset - 1)) = SQUASHFS_MARKER_BYTE; - directory_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + block_offset; - total_directory_bytes += avail_bytes + block_offset; - directoryp += avail_bytes; - directory_cache_bytes -= avail_bytes; - } - write_bytes(fd, bytes, directory_bytes, (char *) directory_table); - bytes += directory_bytes; - - return start_bytes; -} - - -unsigned int get_uid(squashfs_uid uid) -{ - int i; - - for(i = 0; (i < uid_count) && uids[i] != uid; i++); - if(i == uid_count) { - if(uid_count == SQUASHFS_UIDS) { - ERROR("Out of uids! - using uid 0 - probably not what's wanted!\n"); - i = 0; - } else - uids[uid_count++] = uid; - } - - return i; -} - - -unsigned int get_guid(squashfs_uid uid, squashfs_uid guid) -{ - int i; - - if(uid == guid) - return SQUASHFS_GUIDS; - - for(i = 0; (i < guid_count) && guids[i] != guid; i++); - if(i == guid_count) { - if(guid_count == SQUASHFS_GUIDS) { - ERROR("Out of gids! - using gid 0 - probably not what's wanted!\n"); - return SQUASHFS_GUIDS; - } else - guids[guid_count++] = guid; - } - - return i; -} - - -squashfs_inode create_inode(char *filename, int type, int byte_size, -squashfs_block start_block, unsigned int offset, unsigned int *block_list, struct fragment *fragment) -{ - squashfs_inode i_no; - struct stat buf; - squashfs_inode_header inode_header; - squashfs_base_inode_header *inode, *base = &inode_header.base; - - if(filename[0] == '\0') { - /* dummy top level directory, if multiple sources specified on command line */ - buf.st_mode = S_IRWXU | S_IRWXG | S_IRWXO; - buf.st_uid = getuid(); - buf.st_gid = getgid(); - buf.st_mtime = time(NULL); - } else if(lstat(filename, &buf) == -1) { - char buffer[8192]; - sprintf(buffer, "Cannot stat dir/file %s, ignoring", filename); - perror(buffer); - return SQUASHFS_INVALID; - } - - base->mode = SQUASHFS_MODE(buf.st_mode); - base->uid = get_uid((squashfs_uid) global_uid == -1 ? buf.st_uid : global_uid); - base->inode_type = type; - base->guid = get_guid((squashfs_uid) global_uid == -1 ? buf.st_uid : global_uid, (squashfs_uid) global_gid == -1 ? buf.st_gid : global_gid); - - if(type == SQUASHFS_FILE_TYPE) { - int i; - squashfs_reg_inode_header *reg = &inode_header.reg, *inodep; - - inodep = (squashfs_reg_inode_header *) inode = get_inode(sizeof(*reg) + - offset * sizeof(unsigned int)); - reg->mtime = buf.st_mtime; - reg->file_size = byte_size; - reg->start_block = start_block; - reg->fragment = fragment->index; - reg->offset = fragment->offset; - if(!swap) { - memcpy((void *) inodep, (void *) reg, sizeof(*reg)); - memcpy((void *) inodep->block_list, block_list, offset * sizeof(unsigned int)); - } else { - SQUASHFS_SWAP_REG_INODE_HEADER(reg, inodep); - SQUASHFS_SWAP_INTS(block_list, inodep->block_list, offset); - } - TRACE("File inode, file_size %d, start_block %x, blocks %d, fragment %d, offset %d, size %d\n", byte_size, - start_block, offset, fragment->index, fragment->offset, fragment->size); - for(i = 0; i < offset; i++) - TRACE("Block %d, size %d\n", i, block_list[i]); - } - else if(type == SQUASHFS_DIR_TYPE) { - squashfs_dir_inode_header *dir = &inode_header.dir; - - inode = get_inode(sizeof(*dir)); - dir->mtime = buf.st_mtime; - dir->file_size = byte_size; - dir->offset = offset; - dir->start_block = start_block; - if(!swap) - memcpy((void *) inode, (void *) dir, sizeof(*dir)); - else - SQUASHFS_SWAP_DIR_INODE_HEADER(dir, inode); - TRACE("Directory inode, file_size %d, start_block %x, offset %x\n", byte_size, - start_block, offset); - } - else if(type == SQUASHFS_CHRDEV_TYPE || type == SQUASHFS_BLKDEV_TYPE) { - squashfs_dev_inode_header *dev = &inode_header.dev; - - inode = get_inode(sizeof(*dev)); - dev->rdev = (unsigned short) ((major(buf.st_rdev) << 8) | - (minor(buf.st_rdev) & 0xff)); - if(!swap) - memcpy((void *) inode, (void *) dev, sizeof(*dev)); - else - SQUASHFS_SWAP_DEV_INODE_HEADER(dev, inode); - TRACE("Device inode, rdev %x\n", dev->rdev); - } - else if(type == SQUASHFS_SYMLINK_TYPE) { - squashfs_symlink_inode_header *symlink = &inode_header.symlink, *inodep; - int byte; - char buff[65536]; - - if((byte = readlink(filename, buff, 65536)) == -1) { - perror("Error in reading symbolic link, skipping..."); - return SQUASHFS_INVALID; - } - - if(byte == 65536) { - ERROR("Symlink is greater than 65536 bytes! skipping..."); - return SQUASHFS_INVALID; - } - - inodep = (squashfs_symlink_inode_header *) inode = get_inode(sizeof(*symlink) + byte); - symlink->symlink_size = byte; - if(!swap) - memcpy((void *) inode, symlink, sizeof(*symlink)); - else - SQUASHFS_SWAP_SYMLINK_INODE_HEADER(symlink, inode); - strncpy(inodep->symlink, buff, byte); - TRACE("Symbolic link inode, symlink_size %d\n", byte); - } - else if(type == SQUASHFS_FIFO_TYPE || type == SQUASHFS_SOCKET_TYPE) { - squashfs_ipc_inode_header *ipc = &inode_header.ipc; - - inode = get_inode(sizeof(*ipc)); - if(!swap) - memcpy((void *) inode, (void *) ipc, sizeof(*ipc)); - else - SQUASHFS_SWAP_IPC_INODE_HEADER(ipc, inode); - TRACE("ipc inode, type %s %d\n", type == SQUASHFS_FIFO_TYPE ? "fifo" : "socket"); - } else - return SQUASHFS_INVALID; - - i_no = MKINODE(inode); - inode_count ++; - - TRACE("Created inode 0x%Lx, type %d, uid %d, guid %d\n", i_no, type, base->uid, base->guid); - - return i_no; -} - - -void init_dir(struct directory *dir) -{ - if((dir->buff = (char *)malloc(SQUASHFS_METADATA_SIZE)) == NULL) { - BAD_ERROR("Out of memory allocating directory buffer\n"); - } - - dir->size = SQUASHFS_METADATA_SIZE; - dir->p = dir->buff; - dir->entry_count = 256; - dir->entry_count_p = NULL; -} - - -void add_dir(squashfs_inode inode, char *name, int type, struct directory *dir) -{ - char *buff; - squashfs_dir_entry idir, *idirp; - unsigned int start_block = inode >> 16; - unsigned int offset = inode & 0xffff; - unsigned int size; - - if((size = strlen(name)) > SQUASHFS_NAME_LEN) { - size = SQUASHFS_NAME_LEN; - ERROR("Filename is greater than %d characters, truncating! ...\n", SQUASHFS_NAME_LEN); - } - - if(dir->p + sizeof(squashfs_dir_entry) + size + 6 >= dir->buff + dir->size) { - if((buff = (char *) realloc(dir->buff, dir->size += SQUASHFS_METADATA_SIZE)) == NULL) { - BAD_ERROR("Out of memory reallocating directory buffer\n"); - } - - dir->p = (dir->p - dir->buff) + buff; - if(dir->entry_count_p) - dir->entry_count_p = (squashfs_dir_header *) (((unsigned char *) dir->entry_count_p) - - dir->buff + buff); - dir->buff = buff; - } - - if(dir->entry_count == 256 || start_block != dir->start_block) { - if(dir->entry_count_p) { - squashfs_dir_header dir_header; - - dir_header.count = dir->entry_count - 1; - dir_header.start_block = dir->start_block; - if(!swap) - memcpy((void *) dir->entry_count_p, (void *) &dir_header, sizeof(dir_header)); - else - SQUASHFS_SWAP_DIR_HEADER((&dir_header), dir->entry_count_p); - } - - dir->entry_count_p = (squashfs_dir_header *) dir->p; - dir->start_block = start_block; - dir->entry_count = 0; - dir->p += sizeof(squashfs_dir_header); - } - - idirp = (squashfs_dir_entry *) dir->p; - idir.offset = offset; - idir.type = type; - idir.size = size - 1; - if(!swap) - memcpy((void *) idirp, (void *) &idir, sizeof(idir)); - else - SQUASHFS_SWAP_DIR_ENTRY((&idir), idirp); - strncpy(idirp->name, name, size); - dir->p += sizeof(squashfs_dir_entry) + size; - dir->entry_count ++; -} - - -squashfs_inode write_dir(char *filename, struct directory *dir) -{ - squashfs_inode inode; - unsigned int dir_size; - int data_space; - unsigned short c_byte; - - while(directory_cache_bytes >= SQUASHFS_METADATA_SIZE) { - if((directory_size - directory_bytes) < ((SQUASHFS_METADATA_SIZE << 1) + 2)) { - if((directory_table = (char *) realloc(directory_table, - directory_size + (SQUASHFS_METADATA_SIZE << 1) + 2)) == NULL) { - goto failed; - } - directory_size += SQUASHFS_METADATA_SIZE << 1; - } - - c_byte = mangle(directory_table + directory_bytes + block_offset, directory_data_cache, - SQUASHFS_METADATA_SIZE, SQUASHFS_METADATA_SIZE, noI, 0); - TRACE("Directory block @ %x, size %d\n", directory_bytes, c_byte); - if(!swap) - memcpy((void *) directory_table + directory_bytes, (void *) &c_byte, sizeof(unsigned short)); - else - SQUASHFS_SWAP_SHORTS((&c_byte), (directory_table + directory_bytes), 1); - if(check_data) - *((unsigned char *)(directory_table + directory_bytes + block_offset - 1)) = SQUASHFS_MARKER_BYTE; - directory_bytes += SQUASHFS_COMPRESSED_SIZE(c_byte) + block_offset; - total_directory_bytes += SQUASHFS_METADATA_SIZE + block_offset; - memcpy(directory_data_cache, directory_data_cache + SQUASHFS_METADATA_SIZE, directory_cache_bytes - SQUASHFS_METADATA_SIZE); - directory_cache_bytes -= SQUASHFS_METADATA_SIZE; - } - - dir_size = dir->p - dir->buff; - data_space = (directory_cache_size - directory_cache_bytes); - if(data_space < dir_size) { - int realloc_size = directory_cache_size == 0 ? ((dir_size + SQUASHFS_METADATA_SIZE) & ~(SQUASHFS_METADATA_SIZE - 1)) : dir_size - data_space; - - if((directory_data_cache = (char *) realloc(directory_data_cache, directory_cache_size + realloc_size)) == NULL) { - goto failed; - } - directory_cache_size += realloc_size; - } - - if(dir_size) { - squashfs_dir_header dir_header; - - dir_header.count = dir->entry_count - 1; - dir_header.start_block = dir->start_block; - if(!swap) - memcpy((void *) dir->entry_count_p, (void *) &dir_header, sizeof(dir_header)); - else - SQUASHFS_SWAP_DIR_HEADER((&dir_header), dir->entry_count_p); - memcpy(directory_data_cache + directory_cache_bytes, dir->buff, dir_size); - } - - inode = create_inode(filename, SQUASHFS_DIR_TYPE, dir_size, directory_bytes, directory_cache_bytes, NULL, NULL); - - directory_cache_bytes += dir_size; - -#ifdef SQUASHFS_TRACE - if(!swap) { - unsigned char *dirp; - int count; - - TRACE("Directory contents of inode 0x%Lx\n", inode); - dirp = dir->buff; - while(dirp < dir->p) { - char buffer[SQUASHFS_NAME_LEN + 1]; - squashfs_dir_entry idir, *idirp; - squashfs_dir_header *dirh = (squashfs_dir_header *) dirp; - count = dirh->count + 1; - dirp += sizeof(squashfs_dir_header); - - TRACE("\tStart block 0x%x, count %d\n", dirh->start_block, count); - - while(count--) { - idirp = (squashfs_dir_entry *) dirp; - memcpy((char *) &idir, (char *) idirp, sizeof(idir)); - strncpy(buffer, idirp->name, idir.size + 1); - buffer[idir.size + 1] = '\0'; - TRACE("\t\tname %s, inode offset 0x%x, type %d\n", buffer, - idir.offset, idir.type); - dirp += sizeof(squashfs_dir_entry) + idir.size + 1; - } - } - } -#endif - dir_count ++; - - return inode; - -failed: - BAD_ERROR("Out of memory in directory table reallocation!\n"); -} - - -char *get_fragment(char *buffer, struct fragment *fragment) -{ - if(fragment->index == fragments || fragment->index == SQUASHFS_INVALID_BLK) - return fragment_data + fragment->offset; - else { - squashfs_fragment_entry *disk_fragment = &fragment_table[fragment->index]; - int size = SQUASHFS_COMPRESSED_SIZE_BLOCK(disk_fragment->size), res; - long bytes = block_size; - - if(SQUASHFS_COMPRESSED_BLOCK(disk_fragment->size)) { - char cbuffer[block_size]; - - read_bytes(fd, disk_fragment->start_block, size, cbuffer); - - if((res = uncompress(buffer, &bytes, (const char *) cbuffer, size)) != Z_OK) { - if(res == Z_MEM_ERROR) - BAD_ERROR("zlib::uncompress failed, not enough memory\n"); - else if(res == Z_BUF_ERROR) - BAD_ERROR("zlib::uncompress failed, not enough room in output buffer\n"); - else - BAD_ERROR("zlib::uncompress failed, unknown error %d\n", res); - } - } else - read_bytes(fd, disk_fragment->start_block, size, buffer); - return buffer + fragment->offset; - } -} - - -void write_fragment() -{ - int compressed_size; - unsigned char buffer[block_size << 1]; - - if(fragment_size == 0) - return; - - if(fragments % FRAG_SIZE == 0) - if((fragment_table = (squashfs_fragment_entry *) realloc(fragment_table, (fragments + FRAG_SIZE) * sizeof(squashfs_fragment_entry))) == NULL) - BAD_ERROR("Out of memory in fragment table\n"); - fragment_table[fragments].size = mangle(buffer, fragment_data, fragment_size, block_size, noF, 1); - fragment_table[fragments].start_block = bytes; - compressed_size = SQUASHFS_COMPRESSED_SIZE_BLOCK(fragment_table[fragments].size); - write_bytes(fd, bytes, compressed_size, buffer); - bytes += compressed_size; - total_uncompressed += fragment_size; - total_compressed += compressed_size; - TRACE("Writing fragment %d, uncompressed size %d, compressed size %d\n",fragments, fragment_size, compressed_size); - fragments ++; - fragment_size = 0; -} - - -static struct fragment empty_fragment = {SQUASHFS_INVALID_BLK, 0, 0}; -struct fragment *get_and_fill_fragment(char *buff, int size) -{ - struct fragment *ffrg; - - if(size == 0) - return &empty_fragment; - - if(fragment_size + size > block_size) - write_fragment(); - - if((ffrg = (struct fragment *) malloc(sizeof(struct fragment))) == NULL) - BAD_ERROR("Out of memory in fragment block allocation!\n"); - - ffrg->index = fragments; - ffrg->offset = fragment_size; - ffrg->size = size; - memcpy(fragment_data + fragment_size, buff, size); - fragment_size += size; - - return ffrg; -} - - -unsigned int write_fragment_table() -{ - unsigned int start_bytes, frag_bytes = SQUASHFS_FRAGMENT_BYTES(fragments), - meta_blocks = SQUASHFS_FRAGMENT_INDEXES(fragments); - char cbuffer[(SQUASHFS_METADATA_SIZE << 2) + 2], buffer[frag_bytes]; - squashfs_fragment_entry *p = (squashfs_fragment_entry *) buffer; - unsigned short c_byte; - int i, compressed_size; - squashfs_fragment_index list[meta_blocks]; - - TRACE("write_fragment_table: fragments %d, frag_bytes %d, meta_blocks %d\n", fragments, frag_bytes, meta_blocks); - for(i = 0; i < fragments; i++, p++) { - TRACE("write_fragment_table: fragment %d, start_block %x, size %d\n", i, fragment_table[i].start_block, fragment_table[i].size); - if(!swap) - memcpy((void *) p, &fragment_table[i], sizeof(squashfs_fragment_entry)); - else - SQUASHFS_SWAP_FRAGMENT_ENTRY(&fragment_table[i], p); - } - - for(i = 0; i < meta_blocks; i++) { - int avail_bytes = i == meta_blocks - 1 ? frag_bytes % SQUASHFS_METADATA_SIZE : SQUASHFS_METADATA_SIZE; - c_byte = mangle(cbuffer + block_offset, buffer + i * SQUASHFS_METADATA_SIZE , avail_bytes, SQUASHFS_METADATA_SIZE, noF, 0); - if(!swap) - memcpy((void *) cbuffer, (void *) &c_byte, sizeof(unsigned short)); - else - SQUASHFS_SWAP_SHORTS((&c_byte), cbuffer, 1); - if(check_data) - *((unsigned char *)(cbuffer + block_offset - 1)) = SQUASHFS_MARKER_BYTE; - list[i] = bytes; - compressed_size = SQUASHFS_COMPRESSED_SIZE(c_byte) + block_offset; - write_bytes(fd, bytes, compressed_size, cbuffer); - bytes += compressed_size; - } - - if(!swap) - write_bytes(fd, bytes, sizeof(list), (char *) list); - else { - squashfs_fragment_index slist[meta_blocks]; - SQUASHFS_SWAP_FRAGMENT_INDEXES(list, slist, meta_blocks); - write_bytes(fd, bytes, sizeof(list), (char *) slist); - } - - start_bytes = bytes; - bytes += sizeof(list); - - return start_bytes; -} - - -unsigned char *read_from_buffer(struct duplicate_buffer_handle *handle, unsigned int avail_bytes) -{ - unsigned char *v = handle->ptr; - handle->ptr += avail_bytes; - return v; -} - - -char read_from_file_buffer[SQUASHFS_FILE_MAX_SIZE]; -unsigned char *read_from_file(struct duplicate_buffer_handle *handle, unsigned int avail_bytes) -{ - read_bytes(fd, handle->start, avail_bytes, read_from_file_buffer); - handle->start += avail_bytes; - return read_from_file_buffer; -} - - -/* - * Compute 16 bit BSD checksum over the data - */ -unsigned short get_checksum(unsigned char *(get_next_file_block)(struct duplicate_buffer_handle *, unsigned int), struct duplicate_buffer_handle *handle, int l) -{ - unsigned short chksum = 0; - unsigned int bytes = 0; - unsigned char *b; - struct duplicate_buffer_handle position = *handle; - - while(l) { - bytes = l > SQUASHFS_FILE_MAX_SIZE ? SQUASHFS_FILE_MAX_SIZE : l; - l -= bytes; - b = get_next_file_block(&position, bytes); - while(bytes--) { - chksum = (chksum & 1) ? (chksum >> 1) | 0x8000 : chksum >> 1; - chksum += *b++; - } - } - - return chksum; -} - - -static unsigned int cached_frag = -1; -void add_file(int start, int file_bytes, unsigned int *block_listp, int blocks, unsigned int fragment, int offset, int bytes) -{ - struct fragment *frg; - struct file_info *dupl_ptr; - char *datap; - struct duplicate_buffer_handle handle; - - if(!duplicate_checking) - return; - - if((frg = (struct fragment *) malloc(sizeof(struct fragment))) == NULL) - BAD_ERROR("Out of memory in fragment block allocation!\n"); - - frg->index = fragment; - frg->offset = offset; - frg->size = bytes; - if(cached_frag == fragment) - datap = fragment_data + offset; - else - datap = get_fragment(fragment_data, frg); - handle.start = start; - if((dupl_ptr = duplicate(read_from_file, &handle, file_bytes, &block_listp, &start, blocks, &frg, datap, bytes)) != NULL) - dupl_ptr->fragment = frg; - cached_frag = fragment; -} - - -struct file_info *duplicate(unsigned char *(get_next_file_block)(struct duplicate_buffer_handle *, unsigned int), struct duplicate_buffer_handle *file_start, int bytes, unsigned int **block_list, int *start, int blocks, struct fragment **fragment, char *frag_data, int frag_bytes) -{ - unsigned short checksum = get_checksum(get_next_file_block, file_start, bytes); - struct duplicate_buffer_handle handle = { frag_data, 0 }; - unsigned short fragment_checksum = get_checksum(read_from_buffer, &handle, frag_bytes); - struct file_info *dupl_ptr = bytes ? dupl[checksum] : frag_dups[fragment_checksum]; - - - for(; dupl_ptr; dupl_ptr = dupl_ptr->next) - if(bytes == dupl_ptr->bytes && frag_bytes == dupl_ptr->fragment->size && fragment_checksum == dupl_ptr->fragment_checksum) { - unsigned char buffer1[SQUASHFS_FILE_MAX_SIZE]; - unsigned int dup_bytes = dupl_ptr->bytes, dup_start = dupl_ptr->start; - struct duplicate_buffer_handle position = *file_start; - unsigned char *buffer; - while(dup_bytes) { - int avail_bytes = dup_bytes > SQUASHFS_FILE_MAX_SIZE ? SQUASHFS_FILE_MAX_SIZE : dup_bytes; - - buffer = get_next_file_block(&position, avail_bytes); - read_bytes(fd, dup_start, avail_bytes, buffer1); - if(memcmp(buffer, buffer1, avail_bytes) != 0) - break; - dup_bytes -= avail_bytes; - dup_start += avail_bytes; - } - if(dup_bytes == 0) { - char frag_buffer1[block_size]; - char *fragment_buffer1 = get_fragment(frag_buffer1, dupl_ptr->fragment); - if(frag_bytes == 0 || memcmp(frag_data, fragment_buffer1, frag_bytes) == 0) { - TRACE("Found duplicate file, start 0x%x, size %d, checksum 0x%x, fragment %d, size %d, offset %d, checksum 0x%x\n", dupl_ptr->start, - dupl_ptr->bytes, dupl_ptr->checksum, dupl_ptr->fragment->index, frag_bytes, dupl_ptr->fragment->offset, fragment_checksum); - *block_list = dupl_ptr->block_list; - *start = dupl_ptr->start; - *fragment = dupl_ptr->fragment; - return 0; - } - } - } - - - if((dupl_ptr = (struct file_info *) malloc(sizeof(struct file_info))) == NULL) { - BAD_ERROR("Out of memory in dup_files allocation!\n"); - } - - dupl_ptr->bytes = bytes; - dupl_ptr->checksum = checksum; - dupl_ptr->start = *start; - dupl_ptr->fragment_checksum = fragment_checksum; - if((dupl_ptr->block_list = (unsigned int *) malloc(blocks * sizeof(unsigned int))) == NULL) { - BAD_ERROR("Out of memory allocating block_list\n"); - } - - memcpy(dupl_ptr->block_list, *block_list, blocks * sizeof(unsigned int)); - dup_files ++; - if(bytes) { - dupl_ptr->next = dupl[checksum]; - dupl[checksum] = dupl_ptr; - } else { - dupl_ptr->next = frag_dups[fragment_checksum]; - frag_dups[fragment_checksum] = dupl_ptr; - } - - return dupl_ptr; -} - - -#define MINALLOCBYTES (1024 * 1024) -squashfs_inode write_file(char *filename, long long size, int *duplicate_file) -{ - unsigned int frag_bytes, file, start, file_bytes = 0, block = 0; - unsigned int c_byte; - long long read_size = (size > SQUASHFS_MAX_FILE_SIZE) ? SQUASHFS_MAX_FILE_SIZE : size; - unsigned int blocks = (read_size + block_size - 1) >> block_log; - unsigned int block_list[blocks], *block_listp = block_list; - char buff[block_size], *c_buffer; - int allocated_blocks = blocks, i, bbytes, whole_file = 1; - struct fragment *fragment; - struct file_info *dupl_ptr; - struct duplicate_buffer_handle handle; - - if(!no_fragments && (read_size < block_size || always_use_fragments)) { - allocated_blocks = blocks = read_size >> block_log; - frag_bytes = read_size % block_size; - } else - frag_bytes = 0; - - if(size > read_size) - ERROR("file %s truncated to %Ld bytes\n", filename, SQUASHFS_MAX_FILE_SIZE); - - total_bytes += read_size; - if((file = open(filename, O_RDONLY)) == -1) { - perror("Error in opening file, skipping..."); - return SQUASHFS_INVALID; - } - - do { - if((c_buffer = (char *) malloc((allocated_blocks + 1) << block_log)) == NULL) { - TRACE("Out of memory allocating write_file buffer, allocated_blocks %d, blocks %d\n", allocated_blocks, blocks); - whole_file = 0; - if((allocated_blocks << (block_log - 1)) < MINALLOCBYTES) - BAD_ERROR("Out of memory allocating write_file buffer, could not allocate %d blocks (%d Kbytes)\n", allocated_blocks, allocated_blocks << (block_log - 10)); - allocated_blocks >>= 1; - } - } while(!c_buffer); - - for(start = bytes; block < blocks; file_bytes += bbytes) { - for(i = 0, bbytes = 0; (i < allocated_blocks) && (block < blocks); i++) { - int available_bytes = read_size - (block * block_size) > block_size ? block_size : read_size - (block * block_size); - if(read(file, buff, available_bytes) == -1) - goto read_err; - c_byte = mangle(c_buffer + bbytes, buff, available_bytes, block_size, noD, 1); - block_list[block ++] = c_byte; - bbytes += SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte); - } - if(!whole_file) { - write_bytes(fd, bytes, bbytes, c_buffer); - bytes += bbytes; - } - } - - if(frag_bytes != 0) - if(read(file, buff, frag_bytes) == -1) - goto read_err; - - close(file); - if(whole_file) { - handle.ptr = c_buffer; - if(duplicate_checking && (dupl_ptr = duplicate(read_from_buffer, &handle, file_bytes, &block_listp, &start, blocks, &fragment, buff, frag_bytes)) == NULL) { - *duplicate_file = TRUE; - goto wr_inode; - } - write_bytes(fd, bytes, file_bytes, c_buffer); - bytes += file_bytes; - } else { - handle.start = start; - if(duplicate_checking && (dupl_ptr = duplicate(read_from_file, &handle, file_bytes, &block_listp, &start, blocks, &fragment, buff, frag_bytes)) == NULL) { - bytes = start; - if(!block_device) - ftruncate(fd, bytes); - *duplicate_file = TRUE; - goto wr_inode; - } - } - - fragment = get_and_fill_fragment(buff, frag_bytes); - if(duplicate_checking) - dupl_ptr->fragment = fragment; - - *duplicate_file = FALSE; - -wr_inode: - free(c_buffer); - file_count ++; - return create_inode(filename, SQUASHFS_FILE_TYPE, read_size, start, blocks, block_listp, fragment); - -read_err: - perror("Error in reading file, skipping..."); - free(c_buffer); - return SQUASHFS_INVALID; -} - - -struct linuxdir { - DIR *linuxdir; - char pathname[8192]; -}; - - -void *linux_opendir(char *pathname, struct directory *dir) -{ - struct linuxdir *linuxdir; - if((linuxdir = malloc(sizeof(struct linuxdir))) == NULL) - return NULL; - if((linuxdir->linuxdir = opendir(pathname)) == NULL) { - free(linuxdir); - return NULL; - } - strcpy(linuxdir->pathname, pathname); - return (void *) linuxdir; -} - - -int linux_readdir(void *l, char *filename, char *dir_name) -{ - struct dirent *d_name; - struct linuxdir *linuxdir = (struct linuxdir *)l; - - do { - if((d_name = readdir(linuxdir->linuxdir)) == NULL) - return FALSE; - } while(strcmp(d_name->d_name, ".") == 0 || strcmp(d_name->d_name, "..") == 0); - strcat(strcat(strcpy(filename, linuxdir->pathname), "/"), d_name->d_name); - strcpy(dir_name, d_name->d_name); - return TRUE; -} - - -void linux_closedir(void *linuxdir) -{ - closedir(((struct linuxdir *)linuxdir)->linuxdir); - free(linuxdir); -} - - -char b_buffer[8192]; -char *name; -char *basename_r(); - -char *getbase(char *pathname) -{ - char *result; - - if(*pathname != '/') { - result = getenv("PWD"); - strcat(strcat(strcpy(b_buffer, result), "/"), pathname); - } else - strcpy(b_buffer, pathname); - name = b_buffer; - if(((result = basename_r()) == NULL) || (strcmp(result, "..") == 0)) - return NULL; - else - return result; -} - - -char *basename_r() -{ - char *s; - char *p; - int n = 1; - - for(;;) { - s = name; - if(*name == '\0') - return NULL; - if(*name != '/') { - while(*name != '\0' && *name != '/') name++; - n = name - s; - } - while(*name == '/') name++; - if(strncmp(s, ".", n) == 0) - continue; - if((*name == '\0') || (strncmp(s, "..", n) == 0) || ((p = basename_r()) == NULL)) { - s[n] = '\0'; - return s; - } - if(strcmp(p, "..") == 0) - continue; - return p; - } -} - - -char encomp_pathname[8192]; -int encomp_entry = 0; - -void *encomp_opendir(char *pathname, struct directory *dir) -{ - int i; - - for(i = 0; i < old_root_entries; i++) - add_dir(old_root_entry[i].inode, old_root_entry[i].name, old_root_entry[i].type, dir); - - return (void *)source_path; -} - - -int encomp_readdir(void *l, char *filename, char *dir_name) -{ - char *basename; - int n, pass = 1; - - while(encomp_entry < source) { - if((basename = getbase(source_path[encomp_entry])) == NULL) { - ERROR("Bad source directory %s - skipping ...\n", source_path[encomp_entry]); - encomp_entry++; - continue; - } - strcpy(filename, source_path[encomp_entry]); - strcpy(dir_name, basename); - for(;;) { - for(n = 0; n < old_root_entries && strcmp(old_root_entry[n].name, dir_name) != 0; n++); - if(n == old_root_entries) { - add_old_root_entry(dir_name, 0, 0); - encomp_entry++; - return TRUE; - } - ERROR("Source directory entry %s already used! - trying ", dir_name); - sprintf(dir_name, "%s_%d", basename, pass++); - ERROR("%s\n", dir_name); - } - } - return FALSE; -} - - -void encomp_closedir(void *linuxdir) -{ -} - - -void *single_opendir(char *pathname, struct directory *dir) -{ - encomp_opendir(pathname, dir); - return linux_opendir(pathname, dir); -} - - -int single_readdir(void *l, char *filename, char *dir_name) -{ - int i, pass = 1; - char name[SQUASHFS_NAME_LEN + 1]; - - if(linux_readdir(l, filename, dir_name) == FALSE) - return FALSE; - - strcpy(name, dir_name); - for(;;) { - for(i = 0; i < old_root_entries && strcmp(old_root_entry[i].name, dir_name) != 0; i++); - if(i == old_root_entries) { - add_old_root_entry(dir_name, 0, 0); - return TRUE; - } - ERROR("Source directory entry %s already used! - trying ", dir_name); - sprintf(dir_name, "%s_%d", name, pass++); - ERROR("%s\n", dir_name); - } -} - - -squashfs_inode dir_scan(char *pathname, void* (_opendir)(char *, struct directory *), int (_readdir)(void *, char *, char *), - void (_closedir)(void *)) -{ - void *linuxdir; - struct stat buf; - char filename[8192], dir_name[8192]; - int squashfs_type; - squashfs_inode inode = SQUASHFS_INVALID; - struct directory dir; - - init_dir(&dir); - if((linuxdir = _opendir(pathname, &dir)) == NULL) { - ERROR("Could not open %s, skipping...\n", pathname); - goto error; - } - - while(_readdir(linuxdir, filename, dir_name) != FALSE) { - - if(lstat(filename, &buf) == -1) { - char buffer[8192]; - sprintf(buffer, "Cannot stat dir/file %s, ignoring", filename); - perror(buffer); - continue; - } - if(excluded(filename, &buf)) - continue; - - switch(buf.st_mode & S_IFMT) { - case S_IFREG: { - int duplicate_file; - - squashfs_type = SQUASHFS_FILE_TYPE; - if(!sorted) { - inode = write_file(filename, buf.st_size, &duplicate_file); - INFO("file %s, uncompressed size %Ld bytes, %s\n", filename, buf.st_size, duplicate_file ? "DUPLICATE" : ""); - } else - inode = get_sorted_inode(&buf); - break; - } - case S_IFDIR: - squashfs_type = SQUASHFS_DIR_TYPE; - inode = dir_scan(filename, linux_opendir, linux_readdir, linux_closedir); - break; - - case S_IFLNK: - squashfs_type = SQUASHFS_SYMLINK_TYPE; - inode = create_inode(filename, squashfs_type, 0, 0, 0, NULL, NULL); - INFO("symbolic link %s inode 0x%Lx\n", dir_name, inode); - sym_count ++; - break; - - case S_IFCHR: - squashfs_type = SQUASHFS_CHRDEV_TYPE; - inode = create_inode(filename, squashfs_type, 0, 0, 0, NULL, NULL); - INFO("character device %s inode 0x%Lx\n", dir_name, inode); - dev_count ++; - break; - - case S_IFBLK: - squashfs_type = SQUASHFS_BLKDEV_TYPE; - inode = create_inode(filename, squashfs_type, 0, 0, 0, NULL, NULL); - INFO("block device %s inode 0x%Lx\n", dir_name, inode); - dev_count ++; - break; - - case S_IFIFO: - squashfs_type = SQUASHFS_FIFO_TYPE; - inode = create_inode(filename, squashfs_type, 0, 0, 0, NULL, NULL); - INFO("fifo %s inode 0x%Lx\n", dir_name, inode); - fifo_count ++; - break; - - case S_IFSOCK: - squashfs_type = SQUASHFS_SOCKET_TYPE; - inode = create_inode(filename, squashfs_type, 0, 0, 0, NULL, NULL); - INFO("unix domain socket %s inode 0x%Lx\n", dir_name, inode); - sock_count ++; - break; - - default: - ERROR("%s unrecognised file type, mode is %x\n", filename, buf.st_mode); - continue; - } - - if(inode != SQUASHFS_INVALID) - add_dir(inode, dir_name, squashfs_type, &dir); - } - - _closedir(linuxdir); - inode = write_dir(pathname, &dir); - INFO("directory %s inode 0x%Lx\n", pathname, inode); - -error: - free(dir.buff); - - return inode; -} - - -unsigned int slog(unsigned int block) -{ - int i; - - for(i = 9; i <= 16; i++) - if(block == (1 << i)) - return i; - return 0; -} - - -int excluded(char *filename, struct stat *buf) -{ - int i; - - for(i = 0; i < exclude; i++) - if((exclude_paths[i].st_dev == buf->st_dev) && (exclude_paths[i].st_ino == buf->st_ino)) - return TRUE; - return FALSE; -} - - -#define ADD_ENTRY(buf) \ - if(exclude % EXCLUDE_SIZE == 0) {\ - if((exclude_paths = (struct exclude_info *) realloc(exclude_paths, (exclude + EXCLUDE_SIZE) * sizeof(struct exclude_info))) == NULL)\ - BAD_ERROR("Out of memory in exclude dir/file table\n");\ - }\ - exclude_paths[exclude].st_dev = buf.st_dev;\ - exclude_paths[exclude++].st_ino = buf.st_ino; -int add_exclude(char *path) -{ - int i; - char buffer[4096], filename[4096]; - struct stat buf; - - if(path[0] == '/' || strncmp(path, "./", 2) == 0 || strncmp(path, "../", 3) == 0) { - if(lstat(path, &buf) == -1) { - sprintf(buffer, "Cannot stat exclude dir/file %s, ignoring", path); - perror(buffer); - return TRUE; - } - ADD_ENTRY(buf); - return TRUE; - } - - for(i = 0; i < source; i++) { - strcat(strcat(strcpy(filename, source_path[i]), "/"), path); - if(lstat(filename, &buf) == -1) { - if(!(errno == ENOENT || errno == ENOTDIR)) { - sprintf(buffer, "Cannot stat exclude dir/file %s, ignoring", filename); - perror(buffer); - } - continue; - } - ADD_ENTRY(buf); - } - return TRUE; -} - - -void add_old_root_entry(char *name, squashfs_inode inode, int type) -{ - if((old_root_entry = (struct old_root_entry_info *) realloc(old_root_entry, sizeof(struct old_root_entry_info) - * (old_root_entries + 1))) == NULL) - BAD_ERROR("Out of memory in old root directory entries reallocation\n"); - - strcpy(old_root_entry[old_root_entries].name, name); - old_root_entry[old_root_entries].inode = inode; - old_root_entry[old_root_entries++].type = type; -} - - -#define VERSION() \ - printf("mksquashfs version 2.0\n");\ - printf("copyright (C) 2004 Phillip Lougher (plougher@users.sourceforge.net)\n\n"); \ - printf("This program is free software; you can redistribute it and/or\n");\ - printf("modify it under the terms of the GNU General Public License\n");\ - printf("as published by the Free Software Foundation; either version 2,\n");\ - printf("or (at your option) any later version.\n\n");\ - printf("This program is distributed in the hope that it will be useful,\n");\ - printf("but WITHOUT ANY WARRANTY; without even the implied warranty of\n");\ - printf("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n");\ - printf("GNU General Public License for more details.\n"); -int main(int argc, char *argv[]) -{ - struct stat buf; - int i; - squashfs_super_block sBlk; - char *b, *root_name = NULL; - int be, nopad = FALSE, delete = FALSE, keep_as_directory = FALSE, orig_be; - -#if __BYTE_ORDER == __BIG_ENDIAN - be = TRUE; -#else - be = FALSE; -#endif - - block_log = slog(block_size); - if(argc > 1 && strcmp(argv[1], "-version") == 0) { - VERSION(); - exit(0); - } - for(i = 1; i < argc && argv[i][0] != '-'; i++); - if(i < 3) - goto printOptions; - source_path = argv + 1; - source = i - 2; - for(; i < argc; i++) { - if(strcmp(argv[i], "-b") == 0) { - if((++i == argc) || (block_size = strtol(argv[i], &b, 10), *b !='\0')) { - ERROR("%s: -b missing or invalid block size\n", argv[0]); - exit(1); - } - - if((block_log = slog(block_size)) == 0) { - ERROR("%s: -b block size not power of two or not between 512 and 64K\n", argv[0]); - exit(1); - } - } else if(strcmp(argv[i], "-ef") == 0) { - if(++i == argc) { - ERROR("%s: -ef missing filename\n", argv[0]); - exit(1); - } - } else if(strcmp(argv[i], "-no-duplicates") == 0) - duplicate_checking = FALSE; - - else if(strcmp(argv[i], "-no-fragments") == 0) - no_fragments = TRUE; - - else if(strcmp(argv[i], "-always-use-fragments") == 0) - always_use_fragments = TRUE; - - else if(strcmp(argv[i], "-sort") == 0) { - if(++i == argc) { - ERROR("%s: -sort missing filename\n", argv[0]); - exit(1); - } - } else if(strcmp(argv[i], "-all-root") == 0 || - strcmp(argv[i], "-root-owned") == 0) - global_uid = global_gid = 0; - - else if(strcmp(argv[i], "-force-uid") == 0) { - if(++i == argc) { - ERROR("%s: -force-uid missing uid or user\n", argv[0]); - exit(1); - } - if((global_uid = strtoll(argv[i], &b, 10)), *b =='\0') { - if(global_uid < 0 || global_uid > (((long long) 1 << 32) - 1)) { - ERROR("%s: -force-uid uid out of range\n", argv[0]); - exit(1); - } - } else { - struct passwd *uid = getpwnam(argv[i]); - if(uid) - global_uid = uid->pw_uid; - else { - ERROR("%s: -force-uid invalid uid or unknown user\n", argv[0]); - exit(1); - } - } - } else if(strcmp(argv[i], "-force-gid") == 0) { - if(++i == argc) { - ERROR("%s: -force-gid missing gid or group\n", argv[0]); - exit(1); - } - if((global_gid = strtoll(argv[i], &b, 10)), *b =='\0') { - if(global_gid < 0 || global_gid > (((long long) 1 << 32) - 1)) { - ERROR("%s: -force-gid gid out of range\n", argv[0]); - exit(1); - } - } else { - struct group *gid = getgrnam(argv[i]); - if(gid) - global_gid = gid->gr_gid; - else { - ERROR("%s: -force-gid invalid gid or unknown group\n", argv[0]); - exit(1); - } - } - } else if(strcmp(argv[i], "-noI") == 0 || - strcmp(argv[i], "-noInodeCompression") == 0) - noI = TRUE; - - else if(strcmp(argv[i], "-noD") == 0 || - strcmp(argv[i], "-noDataCompression") == 0) - noD = TRUE; - - else if(strcmp(argv[i], "-noF") == 0 || - strcmp(argv[i], "-noFragmentCompression") == 0) - noF = TRUE; - - else if(strcmp(argv[i], "-nopad") == 0) - nopad = TRUE; - - else if(strcmp(argv[i], "-check_data") == 0) - check_data = TRUE; - - else if(strcmp(argv[i], "-info") == 0) - silent = 0; - - else if(strcmp(argv[i], "-be") == 0) - be = TRUE; - - else if(strcmp(argv[i], "-le") == 0) - be = FALSE; - - else if(strcmp(argv[i], "-e") == 0) - break; - - else if(strcmp(argv[i], "-noappend") == 0) - delete = TRUE; - - else if(strcmp(argv[i], "-keep-as-directory") == 0) - keep_as_directory = TRUE; - - else if(strcmp(argv[i], "-root-becomes") == 0) { - if(++i == argc) { - ERROR("%s: -root-becomes: missing name\n", argv[0]); - exit(1); - } - root_name = argv[i]; - } else if(strcmp(argv[i], "-version") == 0) { - VERSION(); - } else { - ERROR("%s: invalid option\n\n", argv[0]); -printOptions: - ERROR("SYNTAX:%s source1 source2 ... dest [options] [-e list of exclude dirs/files]\n", argv[0]); - ERROR("\nOptions are\n"); - ERROR("\t-info\t\t\t\tprint files written to filesystem\n"); - ERROR("\t-sort sort file\t\t\tsort files according to priorities in sort file. One file or dir\n"); - ERROR("\t\t\t\t\twith priority per line. Priority -32768 to 32767, default priority 0\n"); - ERROR("\t-b block size\t\t\tsize of blocks in "); - ERROR("filesystem, default %d\n", SQUASHFS_FILE_SIZE); - ERROR("\t-noappend\t\t\tDo not append to existing filesystem on dest, write a new filesystem\n"); - ERROR("\t\t\t\t\tThis is the default action if dest does not exist, or if no filesystem is on it\n"); - ERROR("\t-keep-as-directory\t\tIf one source directory is specified, create a root directory\n"); - ERROR("\t\t\t\t\tcontaining that directory, rather than the contents of the directory\n"); - ERROR("\t-root-becomes name\t\tWhen appending source files/directories, make the original\n"); - ERROR("\t\t\t\t\troot become a subdirectory in the new root called name, rather\n"); - ERROR("\t\t\t\t\tthan adding the new source items to the original root\n"); - ERROR("\t-noI -noInodeCompression\tdo not compress inode table\n"); - ERROR("\t-noD -noDataCompression\t\tdo not compress data blocks\n"); - ERROR("\t-noF -noFragmentCompression\tdo not compress fragment blocks\n"); - ERROR("\t-no-duplicates\t\t\tdo not perform duplicate checking\n"); - ERROR("\t-no-fragments\t\t\tdo not use fragments\n"); - ERROR("\t-always-use-fragments\t\tuse fragment blocks for files larger than block size\n"); - ERROR("\t-nopad\t\t\t\tdo not pad filesystem to a multiple of 4K\n"); - ERROR("\t-check_data\t\t\tadd checkdata for greater filesystem checks\n"); - ERROR("\t-le\t\t\t\tcreate a little endian filesystem\n"); - ERROR("\t-be\t\t\t\tcreate a big endian filesystem\n"); - ERROR("\t-ef exclude file\t\tfile is a list of exclude dirs/files - one per line\n"); - ERROR("\t-all-root\t\t\toverride file uid/gid and make all file uid/gids owned by root\n"); - ERROR("\t-root-owned\t\t\talternative name for -all-root\n"); - ERROR("\t-force-uid uid\t\t\tset all file uids to uid\n"); - ERROR("\t-force-gid gid\t\t\tset all file gids to gid\n"); - ERROR("\t-version\t\t\tprint version, licence and copyright message\n"); - exit(1); - } - } - - if(stat(argv[source + 1], &buf) == -1) { - if(errno == ENOENT) { /* Does not exist */ - if((fd = open(argv[source + 1], O_CREAT | O_TRUNC | O_RDWR, S_IRWXU)) == -1) { - perror("Could not create destination file"); - exit(1); - } - delete = TRUE; - } else { - perror("Could not stat destination file"); - exit(1); - } - - } else { - if(S_ISBLK(buf.st_mode)) { - if((fd = open(argv[source + 1], O_RDWR)) == -