Menu
▾
▴
[Squashfs-devel] [patch 1/6] squashfs: Kill support for pre-3.0 squashfs images
|
From: Geert U. <Gee...@so...> - 2008-06-13 14:59:34
|
squashfs: Kill support for pre-3.0 squashfs images
Signed-off-by: Geert Uytterhoeven <Gee...@so...>
---
fs/squashfs/Makefile | 1
fs/squashfs/inode.c | 84 ++--
fs/squashfs/squashfs.h | 43 --
fs/squashfs/squashfs2_0.c | 740 --------------------------------------------
include/linux/squashfs_fs.h | 338 --------------------
5 files changed, 34 insertions(+), 1172 deletions(-)
--- a/fs/squashfs/Makefile
+++ b/fs/squashfs/Makefile
@@ -4,4 +4,3 @@
obj-$(CONFIG_SQUASHFS) += squashfs.o
squashfs-y += inode.o
-squashfs-y += squashfs2_0.o
--- a/fs/squashfs/inode.c
+++ b/fs/squashfs/inode.c
@@ -86,11 +86,11 @@ static struct export_operations squashfs
.get_parent = squashfs_get_parent
};
-SQSH_EXTERN const struct address_space_operations squashfs_symlink_aops = {
+static const struct address_space_operations squashfs_symlink_aops = {
.readpage = squashfs_symlink_readpage
};
-SQSH_EXTERN const struct address_space_operations squashfs_aops = {
+static const struct address_space_operations squashfs_aops = {
.readpage = squashfs_readpage
};
@@ -99,7 +99,7 @@ static const struct file_operations squa
.readdir = squashfs_readdir
};
-SQSH_EXTERN struct inode_operations squashfs_dir_inode_ops = {
+static struct inode_operations squashfs_dir_inode_ops = {
.lookup = squashfs_lookup
};
@@ -171,7 +171,7 @@ out:
}
-SQSH_EXTERN unsigned int squashfs_read_data(struct super_block *s, char *buffer,
+static unsigned int squashfs_read_data(struct super_block *s, char *buffer,
long long index, unsigned int length,
long long *next_index, int srclength)
{
@@ -490,7 +490,7 @@ failed:
}
-SQSH_EXTERN int squashfs_get_cached_block(struct super_block *s, void *buffer,
+static int squashfs_get_cached_block(struct super_block *s, void *buffer,
long long block, unsigned int offset,
int length, long long *next_block,
unsigned int *next_offset)
@@ -569,14 +569,14 @@ out:
}
-SQSH_EXTERN void release_cached_fragment(struct squashfs_sb_info *msblk,
+static void release_cached_fragment(struct squashfs_sb_info *msblk,
struct squashfs_cache_entry *fragment)
{
squashfs_cache_put(msblk->fragment_cache, fragment);
}
-SQSH_EXTERN
+static
struct squashfs_cache_entry *get_cached_fragment(struct super_block *s,
long long start_block, int length)
{
@@ -633,6 +633,22 @@ out:
}
+static struct inode *squashfs_iget(struct super_block *s,
+ squashfs_inode_t inode, unsigned int inode_number)
+{
+ struct squashfs_sb_info *msblk = s->s_fs_info;
+ struct inode *i = iget_locked(s, inode_number);
+
+ TRACE("Entered squashfs_iget\n");
+
+ if(i && (i->i_state & I_NEW)) {
+ (msblk->read_inode)(i, inode);
+ unlock_new_inode(i);
+ }
+
+ return i;
+}
+
static struct dentry *squashfs_export_iget(struct super_block *s,
unsigned int inode_number)
@@ -697,23 +713,6 @@ static struct dentry *squashfs_get_paren
}
-SQSH_EXTERN struct inode *squashfs_iget(struct super_block *s,
- squashfs_inode_t inode, unsigned int inode_number)
-{
- struct squashfs_sb_info *msblk = s->s_fs_info;
- struct inode *i = iget_locked(s, inode_number);
-
- TRACE("Entered squashfs_iget\n");
-
- if(i && (i->i_state & I_NEW)) {
- (msblk->read_inode)(i, inode);
- unlock_new_inode(i);
- }
-
- return i;
-}
-
-
static int squashfs_read_inode(struct inode *i, squashfs_inode_t inode)
{
struct super_block *s = i->i_sb;
@@ -1062,24 +1061,14 @@ static int supported_squashfs_filesystem
msblk->read_blocklist = read_blocklist;
msblk->read_fragment_index_table = read_fragment_index_table;
- if (sblk->s_major == 1) {
- if (!squashfs_1_0_supported(msblk)) {
- SERROR("Major/Minor mismatch, Squashfs 1.0 filesystems "
- "are unsupported\n");
- SERROR("Please recompile with Squashfs 1.0 support enabled\n");
- return 0;
- }
- } else if (sblk->s_major == 2) {
- if (!squashfs_2_0_supported(msblk)) {
- SERROR("Major/Minor mismatch, Squashfs 2.0 filesystems "
- "are unsupported\n");
- SERROR("Please recompile with Squashfs 2.0 support enabled\n");
- return 0;
- }
- } else if(sblk->s_major != SQUASHFS_MAJOR || sblk->s_minor >
- SQUASHFS_MINOR) {
- SERROR("Major/Minor mismatch, trying to mount newer %d.%d "
- "filesystem\n", sblk->s_major, sblk->s_minor);
+ if (sblk->s_major < SQUASHFS_MAJOR) {
+ SERROR("Major/Minor mismatch, Squashfs %u.%u filesystems are "
+ "no longer supported\n", sblk->s_major, sblk->s_minor);
+ return 0;
+ } else if (sblk->s_major > SQUASHFS_MAJOR ||
+ sblk->s_minor > SQUASHFS_MINOR) {
+ SERROR("Major/Minor mismatch, trying to mount newer %u.%u "
+ "filesystem\n", sblk->s_major, sblk->s_minor);
SERROR("Please update your kernel\n");
return 0;
}
@@ -1170,14 +1159,12 @@ static int squashfs_fill_super(struct su
TRACE("Filesystem size %lld bytes\n", sblk->bytes_used);
TRACE("Block size %d\n", sblk->block_size);
TRACE("Number of inodes %d\n", sblk->inodes);
- if (sblk->s_major > 1)
- TRACE("Number of fragments %d\n", sblk->fragments);
+ 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 %llx\n", sblk->inode_table_start);
TRACE("sblk->directory_table_start %llx\n", sblk->directory_table_start);
- if (sblk->s_major > 1)
- TRACE("sblk->fragment_table_start %llx\n", sblk->fragment_table_start);
+ TRACE("sblk->fragment_table_start %llx\n", sblk->fragment_table_start);
TRACE("sblk->uid_start %llx\n", sblk->uid_start);
s->s_maxbytes = MAX_LFS_FILESIZE;
@@ -1228,9 +1215,6 @@ static int squashfs_fill_super(struct su
}
- if (sblk->s_major == 1 && squashfs_1_0_supported(msblk))
- goto allocate_root;
-
msblk->fragment_cache = squashfs_cache_init("fragment",
SQUASHFS_CACHED_FRAGMENTS, sblk->block_size, 1);
if (msblk->fragment_cache == NULL)
@@ -1240,7 +1224,7 @@ static int squashfs_fill_super(struct su
if (msblk->read_fragment_index_table(s) == 0)
goto failed_mount;
- if(sblk->s_major < 3 || sblk->lookup_table_start == SQUASHFS_INVALID_BLK)
+ if(sblk->lookup_table_start == SQUASHFS_INVALID_BLK)
goto allocate_root;
/* Allocate and read inode lookup table */
--- a/fs/squashfs/squashfs.h
+++ b/fs/squashfs/squashfs.h
@@ -21,10 +21,6 @@
* squashfs.h
*/
-#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
-#undef CONFIG_SQUASHFS_1_0_COMPATIBILITY
-#endif
-
#ifdef SQUASHFS_TRACE
#define TRACE(s, args...) printk(KERN_NOTICE "SQUASHFS: "s, ## args)
#else
@@ -45,42 +41,3 @@ static inline struct squashfs_inode_info
return list_entry(inode, struct squashfs_inode_info, vfs_inode);
}
-#if defined(CONFIG_SQUASHFS_1_0_COMPATIBILITY ) || defined(CONFIG_SQUASHFS_2_0_COMPATIBILITY)
-#define SQSH_EXTERN
-extern unsigned int squashfs_read_data(struct super_block *s, char *buffer,
- long long index, unsigned int length,
- long long *next_index, int srclength);
-extern int squashfs_get_cached_block(struct super_block *s, void *buffer,
- long long block, unsigned int offset,
- int length, long long *next_block,
- unsigned int *next_offset);
-extern void release_cached_fragment(struct squashfs_sb_info *msblk, struct
- squashfs_cache_entry *fragment);
-extern struct squashfs_cache_entry *get_cached_fragment(struct super_block
- *s, long long start_block,
- int length);
-extern struct inode *squashfs_iget(struct super_block *s, squashfs_inode_t inode, unsigned int inode_number);
-extern const struct address_space_operations squashfs_symlink_aops;
-extern const struct address_space_operations squashfs_aops;
-extern struct inode_operations squashfs_dir_inode_ops;
-#else
-#define SQSH_EXTERN static
-#endif
-
-#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
-extern int squashfs_1_0_supported(struct squashfs_sb_info *msblk);
-#else
-static inline int squashfs_1_0_supported(struct squashfs_sb_info *msblk)
-{
- return 0;
-}
-#endif
-
-#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY
-extern int squashfs_2_0_supported(struct squashfs_sb_info *msblk);
-#else
-static inline int squashfs_2_0_supported(struct squashfs_sb_info *msblk)
-{
- return 0;
-}
-#endif
--- a/fs/squashfs/squashfs2_0.c
+++ /dev/null
@@ -1,740 +0,0 @@
-/*
- * Squashfs - a compressed read only filesystem for Linux
- *
- * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007
- * Phillip Lougher <ph...@lo...>
- *
- * 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.
- *
- * squashfs2_0.c
- */
-
-#include <linux/squashfs_fs.h>
-#include <linux/module.h>
-#include <linux/zlib.h>
-#include <linux/fs.h>
-#include <linux/squashfs_fs_sb.h>
-#include <linux/squashfs_fs_i.h>
-
-#include "squashfs.h"
-static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir);
-static struct dentry *squashfs_lookup_2(struct inode *, struct dentry *,
- struct nameidata *);
-
-static struct file_operations squashfs_dir_ops_2 = {
- .read = generic_read_dir,
- .readdir = squashfs_readdir_2
-};
-
-static struct inode_operations squashfs_dir_inode_ops_2 = {
- .lookup = squashfs_lookup_2
-};
-
-static unsigned char squashfs_filetype_table[] = {
- DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK
-};
-
-static int read_fragment_index_table_2(struct super_block *s)
-{
- struct squashfs_sb_info *msblk = s->s_fs_info;
- struct squashfs_super_block *sblk = &msblk->sblk;
-
- if (!(msblk->fragment_index_2 = kmalloc(SQUASHFS_FRAGMENT_INDEX_BYTES_2
- (sblk->fragments), GFP_KERNEL))) {
- ERROR("Failed to allocate uid/gid table\n");
- return 0;
- }
-
- if (SQUASHFS_FRAGMENT_INDEX_BYTES_2(sblk->fragments) &&
- !squashfs_read_data(s, (char *)
- msblk->fragment_index_2,
- sblk->fragment_table_start,
- SQUASHFS_FRAGMENT_INDEX_BYTES_2
- (sblk->fragments) |
- SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, SQUASHFS_FRAGMENT_INDEX_BYTES_2(sblk->fragments))) {
- ERROR("unable to read fragment index table\n");
- return 0;
- }
-
- if (msblk->swap) {
- int i;
- unsigned int fragment;
-
- for (i = 0; i < SQUASHFS_FRAGMENT_INDEXES_2(sblk->fragments);
- i++) {
- SQUASHFS_SWAP_FRAGMENT_INDEXES_2((&fragment),
- &msblk->fragment_index_2[i], 1);
- msblk->fragment_index_2[i] = fragment;
- }
- }
-
- return 1;
-}
-
-
-static int get_fragment_location_2(struct super_block *s, unsigned int fragment,
- long long *fragment_start_block,
- unsigned int *fragment_size)
-{
- struct squashfs_sb_info *msblk = s->s_fs_info;
- long long start_block =
- msblk->fragment_index_2[SQUASHFS_FRAGMENT_INDEX_2(fragment)];
- int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET_2(fragment);
- struct squashfs_fragment_entry_2 fragment_entry;
-
- if (msblk->swap) {
- struct squashfs_fragment_entry_2 sfragment_entry;
-
- if (!squashfs_get_cached_block(s, (char *) &sfragment_entry,
- start_block, offset,
- sizeof(sfragment_entry), &start_block,
- &offset))
- goto out;
- SQUASHFS_SWAP_FRAGMENT_ENTRY_2(&fragment_entry, &sfragment_entry);
- } else
- if (!squashfs_get_cached_block(s, (char *) &fragment_entry,
- start_block, offset,
- sizeof(fragment_entry), &start_block,
- &offset))
- goto out;
-
- *fragment_start_block = fragment_entry.start_block;
- *fragment_size = fragment_entry.size;
-
- return 1;
-
-out:
- return 0;
-}
-
-
-static void squashfs_new_inode(struct squashfs_sb_info *msblk, struct inode *i,
- struct squashfs_base_inode_header_2 *inodeb, unsigned int ino)
-{
- struct squashfs_super_block *sblk = &msblk->sblk;
-
- i->i_ino = ino;
- i->i_mtime.tv_sec = sblk->mkfs_time;
- i->i_atime.tv_sec = sblk->mkfs_time;
- i->i_ctime.tv_sec = sblk->mkfs_time;
- i->i_uid = msblk->uid[inodeb->uid];
- i->i_mode = inodeb->mode;
- i->i_nlink = 1;
- i->i_size = 0;
- if (inodeb->guid == SQUASHFS_GUIDS)
- i->i_gid = i->i_uid;
- else
- i->i_gid = msblk->guid[inodeb->guid];
-}
-
-
-static int squashfs_read_inode_2(struct inode *i, squashfs_inode_t inode)
-{
- struct super_block *s = i->i_sb;
- struct squashfs_sb_info *msblk = s->s_fs_info;
- struct squashfs_super_block *sblk = &msblk->sblk;
- unsigned int block = SQUASHFS_INODE_BLK(inode) +
- sblk->inode_table_start;
- unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
- unsigned int ino = SQUASHFS_MK_VFS_INODE(block -
- sblk->inode_table_start, offset);
- long long next_block;
- unsigned int next_offset;
- union squashfs_inode_header_2 id, sid;
- struct squashfs_base_inode_header_2 *inodeb = &id.base,
- *sinodeb = &sid.base;
-
- TRACE("Entered squashfs_read_inode_2\n");
-
- if (msblk->swap) {
- if (!squashfs_get_cached_block(s, (char *) sinodeb, block,
- offset, sizeof(*sinodeb), &next_block,
- &next_offset))
- goto failed_read;
- SQUASHFS_SWAP_BASE_INODE_HEADER_2(inodeb, sinodeb,
- sizeof(*sinodeb));
- } else
- if (!squashfs_get_cached_block(s, (char *) inodeb, block,
- offset, sizeof(*inodeb), &next_block,
- &next_offset))
- goto failed_read;
-
- squashfs_new_inode(msblk, i, inodeb, ino);
-
- switch(inodeb->inode_type) {
- case SQUASHFS_FILE_TYPE: {
- struct squashfs_reg_inode_header_2 *inodep = &id.reg;
- struct squashfs_reg_inode_header_2 *sinodep = &sid.reg;
- long long frag_blk;
- unsigned int frag_size = 0;
-
- if (msblk->swap) {
- if (!squashfs_get_cached_block(s, (char *)
- sinodep, block, offset,
- sizeof(*sinodep), &next_block,
- &next_offset))
- goto failed_read;
- SQUASHFS_SWAP_REG_INODE_HEADER_2(inodep, sinodep);
- } else
- if (!squashfs_get_cached_block(s, (char *)
- inodep, block, offset,
- sizeof(*inodep), &next_block,
- &next_offset))
- goto failed_read;
-
- frag_blk = SQUASHFS_INVALID_BLK;
- if (inodep->fragment != SQUASHFS_INVALID_FRAG &&
- !get_fragment_location_2(s,
- inodep->fragment, &frag_blk, &frag_size))
- goto failed_read;
-
- i->i_size = inodep->file_size;
- i->i_fop = &generic_ro_fops;
- i->i_mode |= S_IFREG;
- i->i_mtime.tv_sec = inodep->mtime;
- i->i_atime.tv_sec = inodep->mtime;
- i->i_ctime.tv_sec = inodep->mtime;
- i->i_blocks = ((i->i_size - 1) >> 9) + 1;
- SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk;
- SQUASHFS_I(i)->u.s1.fragment_size = frag_size;
- SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset;
- SQUASHFS_I(i)->start_block = inodep->start_block;
- SQUASHFS_I(i)->u.s1.block_list_start = next_block;
- SQUASHFS_I(i)->offset = next_offset;
- i->i_data.a_ops = &squashfs_aops;
-
- TRACE("File inode %x:%x, start_block %x, "
- "block_list_start %llx, offset %x\n",
- SQUASHFS_INODE_BLK(inode), offset,
- inodep->start_block, next_block,
- next_offset);
- break;
- }
- case SQUASHFS_DIR_TYPE: {
- struct squashfs_dir_inode_header_2 *inodep = &id.dir;
- struct squashfs_dir_inode_header_2 *sinodep = &sid.dir;
-
- if (msblk->swap) {
- if (!squashfs_get_cached_block(s, (char *)
- sinodep, block, offset,
- sizeof(*sinodep), &next_block,
- &next_offset))
- goto failed_read;
- SQUASHFS_SWAP_DIR_INODE_HEADER_2(inodep, sinodep);
- } 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_2;
- i->i_fop = &squashfs_dir_ops_2;
- i->i_mode |= S_IFDIR;
- i->i_mtime.tv_sec = inodep->mtime;
- i->i_atime.tv_sec = inodep->mtime;
- i->i_ctime.tv_sec = inodep->mtime;
- SQUASHFS_I(i)->start_block = inodep->start_block;
- SQUASHFS_I(i)->offset = inodep->offset;
- SQUASHFS_I(i)->u.s2.directory_index_count = 0;
- SQUASHFS_I(i)->u.s2.parent_inode = 0;
-
- TRACE("Directory inode %x:%x, start_block %x, offset "
- "%x\n", SQUASHFS_INODE_BLK(inode),
- offset, inodep->start_block,
- inodep->offset);
- break;
- }
- case SQUASHFS_LDIR_TYPE: {
- struct squashfs_ldir_inode_header_2 *inodep = &id.ldir;
- struct squashfs_ldir_inode_header_2 *sinodep = &sid.ldir;
-
- if (msblk->swap) {
- if (!squashfs_get_cached_block(s, (char *)
- sinodep, block, offset,
- sizeof(*sinodep), &next_block,
- &next_offset))
- goto failed_read;
- SQUASHFS_SWAP_LDIR_INODE_HEADER_2(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_2;
- i->i_fop = &squashfs_dir_ops_2;
- i->i_mode |= S_IFDIR;
- i->i_mtime.tv_sec = inodep->mtime;
- i->i_atime.tv_sec = inodep->mtime;
- i->i_ctime.tv_sec = inodep->mtime;
- SQUASHFS_I(i)->start_block = inodep->start_block;
- SQUASHFS_I(i)->offset = inodep->offset;
- SQUASHFS_I(i)->u.s2.directory_index_start = next_block;
- SQUASHFS_I(i)->u.s2.directory_index_offset =
- next_offset;
- SQUASHFS_I(i)->u.s2.directory_index_count =
- inodep->i_count;
- SQUASHFS_I(i)->u.s2.parent_inode = 0;
-
- TRACE("Long 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: {
- struct squashfs_symlink_inode_header_2 *inodep =
- &id.symlink;
- struct squashfs_symlink_inode_header_2 *sinodep =
- &sid.symlink;
-
- if (msblk->swap) {
- if (!squashfs_get_cached_block(s, (char *)
- sinodep, block, offset,
- sizeof(*sinodep), &next_block,
- &next_offset))
- goto failed_read;
- SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(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;
- SQUASHFS_I(i)->start_block = next_block;
- SQUASHFS_I(i)->offset = next_offset;
-
- TRACE("Symbolic link inode %x:%x, start_block %llx, "
- "offset %x\n",
- SQUASHFS_INODE_BLK(inode), offset,
- next_block, next_offset);
- break;
- }
- case SQUASHFS_BLKDEV_TYPE:
- case SQUASHFS_CHRDEV_TYPE: {
- struct squashfs_dev_inode_header_2 *inodep = &id.dev;
- struct squashfs_dev_inode_header_2 *sinodep = &sid.dev;
-
- if (msblk->swap) {
- if (!squashfs_get_cached_block(s, (char *)
- sinodep, block, offset,
- sizeof(*sinodep), &next_block,
- &next_offset))
- goto failed_read;
- SQUASHFS_SWAP_DEV_INODE_HEADER_2(inodep, sinodep);
- } else
- if (!squashfs_get_cached_block(s, (char *)
- inodep, block, offset,
- sizeof(*inodep), &next_block,
- &next_offset))
- goto failed_read;
-
- i->i_mode |= (inodeb->inode_type ==
- SQUASHFS_CHRDEV_TYPE) ? S_IFCHR :
- S_IFBLK;
- init_special_inode(i, i->i_mode,
- old_decode_dev(inodep->rdev));
-
- TRACE("Device inode %x:%x, rdev %x\n",
- SQUASHFS_INODE_BLK(inode), offset,
- inodep->rdev);
- break;
- }
- case SQUASHFS_FIFO_TYPE:
- case SQUASHFS_SOCKET_TYPE: {
-
- 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;
- }
-
- return 1;
-
-failed_read:
- ERROR("Unable to read inode [%x:%x]\n", block, offset);
-
-failed_read1:
- return 0;
-}
-
-
-static int get_dir_index_using_offset(struct super_block *s, long long
- *next_block, unsigned int *next_offset,
- long long index_start,
- unsigned int index_offset, int i_count,
- long long f_pos)
-{
- struct squashfs_sb_info *msblk = s->s_fs_info;
- struct squashfs_super_block *sblk = &msblk->sblk;
- int i, length = 0;
- struct squashfs_dir_index_2 index;
-
- TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %d\n",
- i_count, (unsigned int) f_pos);
-
- if (f_pos == 0)
- goto finish;
-
- for (i = 0; i < i_count; i++) {
- if (msblk->swap) {
- struct squashfs_dir_index_2 sindex;
- squashfs_get_cached_block(s, (char *) &sindex,
- index_start, index_offset,
- sizeof(sindex), &index_start,
- &index_offset);
- SQUASHFS_SWAP_DIR_INDEX_2(&index, &sindex);
- } else
- squashfs_get_cached_block(s, (char *) &index,
- index_start, index_offset,
- sizeof(index), &index_start,
- &index_offset);
-
- if (index.index > f_pos)
- break;
-
- squashfs_get_cached_block(s, NULL, index_start, index_offset,
- index.size + 1, &index_start,
- &index_offset);
-
- length = index.index;
- *next_block = index.start_block + sblk->directory_table_start;
- }
-
- *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
-
-finish:
- return length;
-}
-
-
-static int get_dir_index_using_name(struct super_block *s, long long
- *next_block, unsigned int *next_offset,
- long long index_start,
- unsigned int index_offset, int i_count,
- const char *name, int size)
-{
- struct squashfs_sb_info *msblk = s->s_fs_info;
- struct squashfs_super_block *sblk = &msblk->sblk;
- int i, length = 0;
- struct squashfs_dir_index_2 *index;
- char *str;
-
- TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count);
-
- if (!(str = kmalloc(sizeof(struct squashfs_dir_index) +
- (SQUASHFS_NAME_LEN + 1) * 2, GFP_KERNEL))) {
- ERROR("Failed to allocate squashfs_dir_index\n");
- goto failure;
- }
-
- index = (struct squashfs_dir_index_2 *) (str + SQUASHFS_NAME_LEN + 1);
- strncpy(str, name, size);
- str[size] = '\0';
-
- for (i = 0; i < i_count; i++) {
- if (msblk->swap) {
- struct squashfs_dir_index_2 sindex;
- squashfs_get_cached_block(s, (char *) &sindex,
- index_start, index_offset,
- sizeof(sindex), &index_start,
- &index_offset);
- SQUASHFS_SWAP_DIR_INDEX_2(index, &sindex);
- } else
- squashfs_get_cached_block(s, (char *) index,
- index_start, index_offset,
- sizeof(struct squashfs_dir_index_2),
- &index_start, &index_offset);
-
- squashfs_get_cached_block(s, index->name, index_start,
- index_offset, index->size + 1,
- &index_start, &index_offset);
-
- index->name[index->size + 1] = '\0';
-
- if (strcmp(index->name, str) > 0)
- break;
-
- length = index->index;
- *next_block = index->start_block + sblk->directory_table_start;
- }
-
- *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
- kfree(str);
-failure:
- return length;
-}
-
-
-static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir)
-{
- struct inode *i = file->f_dentry->d_inode;
- struct squashfs_sb_info *msblk = i->i_sb->s_fs_info;
- struct squashfs_super_block *sblk = &msblk->sblk;
- long long next_block = SQUASHFS_I(i)->start_block +
- sblk->directory_table_start;
- int next_offset = SQUASHFS_I(i)->offset, length = 0,
- dir_count;
- struct squashfs_dir_header_2 dirh;
- struct squashfs_dir_entry_2 *dire;
-
- TRACE("Entered squashfs_readdir_2 [%llx:%x]\n", next_block, next_offset);
-
- if (!(dire = kmalloc(sizeof(struct squashfs_dir_entry) +
- SQUASHFS_NAME_LEN + 1, GFP_KERNEL))) {
- ERROR("Failed to allocate squashfs_dir_entry\n");
- goto finish;
- }
-
- length = get_dir_index_using_offset(i->i_sb, &next_block, &next_offset,
- SQUASHFS_I(i)->u.s2.directory_index_start,
- SQUASHFS_I(i)->u.s2.directory_index_offset,
- SQUASHFS_I(i)->u.s2.directory_index_count,
- file->f_pos);
-
- while (length < i_size_read(i)) {
- /* read directory header */
- if (msblk->swap) {
- struct squashfs_dir_header_2 sdirh;
-
- if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
- next_block, next_offset, sizeof(sdirh),
- &next_block, &next_offset))
- goto failed_read;
-
- length += sizeof(sdirh);
- SQUASHFS_SWAP_DIR_HEADER_2(&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) {
- struct squashfs_dir_entry_2 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_2(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");
- goto finish;
- }
- file->f_pos = length;
- }
- }
-
-finish:
- kfree(dire);
- return 0;
-
-failed_read:
- ERROR("Unable to read directory block [%llx:%x]\n", next_block,
- next_offset);
- kfree(dire);
- return 0;
-}
-
-
-static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry,
- struct nameidata *nd)
-{
- const unsigned char *name = dentry->d_name.name;
- int len = dentry->d_name.len;
- struct inode *inode = NULL;
- struct squashfs_sb_info *msblk = i->i_sb->s_fs_info;
- struct squashfs_super_block *sblk = &msblk->sblk;
- long long next_block = SQUASHFS_I(i)->start_block +
- sblk->directory_table_start;
- int next_offset = SQUASHFS_I(i)->offset, length = 0,
- dir_count;
- struct squashfs_dir_header_2 dirh;
- struct squashfs_dir_entry_2 *dire;
- int sorted = sblk->s_major == 2 && sblk->s_minor >= 1;
-
- TRACE("Entered squashfs_lookup_2 [%llx:%x]\n", next_block, next_offset);
-
- if (!(dire = kmalloc(sizeof(struct squashfs_dir_entry) +
- SQUASHFS_NAME_LEN + 1, GFP_KERNEL))) {
- ERROR("Failed to allocate squashfs_dir_entry\n");
- goto exit_loop;
- }
-
- if (len > SQUASHFS_NAME_LEN)
- goto exit_loop;
-
- length = get_dir_index_using_name(i->i_sb, &next_block, &next_offset,
- SQUASHFS_I(i)->u.s2.directory_index_start,
- SQUASHFS_I(i)->u.s2.directory_index_offset,
- SQUASHFS_I(i)->u.s2.directory_index_count, name,
- len);
-
- while (length < i_size_read(i)) {
- /* read directory header */
- if (msblk->swap) {
- struct squashfs_dir_header_2 sdirh;
- if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
- next_block, next_offset, sizeof(sdirh),
- &next_block, &next_offset))
- goto failed_read;
-
- length += sizeof(sdirh);
- SQUASHFS_SWAP_DIR_HEADER_2(&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) {
- struct squashfs_dir_entry_2 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_2(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 (sorted && name[0] < dire->name[0])
- goto exit_loop;
-
- if ((len == dire->size + 1) && !strncmp(name,
- dire->name, len)) {
- squashfs_inode_t ino =
- SQUASHFS_MKINODE(dirh.start_block,
- dire->offset);
- unsigned int inode_number = SQUASHFS_MK_VFS_INODE(dirh.start_block,
- dire->offset);
-
- TRACE("calling squashfs_iget for directory "
- "entry %s, inode %x:%x, %lld\n", name,
- dirh.start_block, dire->offset, ino);
-
- inode = squashfs_iget(i->i_sb, ino, inode_number);
-
- goto exit_loop;
- }
- }
- }
-
-exit_loop:
- kfree(dire);
- d_add(dentry, inode);
- return ERR_PTR(0);
-
-failed_read:
- ERROR("Unable to read directory block [%llx:%x]\n", next_block,
- next_offset);
- goto exit_loop;
-}
-
-
-int squashfs_2_0_supported(struct squashfs_sb_info *msblk)
-{
- struct squashfs_super_block *sblk = &msblk->sblk;
-
- msblk->read_inode = squashfs_read_inode_2;
- msblk->read_fragment_index_table = read_fragment_index_table_2;
-
- sblk->bytes_used = sblk->bytes_used_2;
- sblk->uid_start = sblk->uid_start_2;
- sblk->guid_start = sblk->guid_start_2;
- sblk->inode_table_start = sblk->inode_table_start_2;
- sblk->directory_table_start = sblk->directory_table_start_2;
- sblk->fragment_table_start = sblk->fragment_table_start_2;
-
- return 1;
-}
--- a/include/linux/squashfs_fs.h
+++ b/include/linux/squashfs_fs.h
@@ -24,10 +24,6 @@
* squashfs_fs.h
*/
-#ifndef CONFIG_SQUASHFS_2_0_COMPATIBILITY
-#define CONFIG_SQUASHFS_2_0_COMPATIBILITY
-#endif
-
#define SQUASHFS_CACHED_FRAGMENTS CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
#define SQUASHFS_MAJOR 3
#define SQUASHFS_MINOR 1
@@ -564,340 +560,6 @@ extern int squashfs_uncompress_exit(void
#define SQUASHFS_SWAP_FRAGMENT_INDEXES(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n)
#define SQUASHFS_SWAP_LOOKUP_BLOCKS(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n)
-#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
-
-struct squashfs_base_inode_header_1 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:4; /* index into uid table */
- unsigned int guid:4; /* index into guid table */
-} __attribute__ ((packed));
-
-struct squashfs_ipc_inode_header_1 {
- 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));
-
-struct squashfs_dev_inode_header_1 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:4; /* index into uid table */
- unsigned int guid:4; /* index into guid table */
- unsigned short rdev;
-} __attribute__ ((packed));
-
-struct squashfs_symlink_inode_header_1 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:4; /* index into uid table */
- unsigned int guid:4; /* index into guid table */
- unsigned short symlink_size;
- char symlink[0];
-} __attribute__ ((packed));
-
-struct squashfs_reg_inode_header_1 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:4; /* index into uid table */
- unsigned int guid:4; /* index into guid table */
- unsigned int mtime;
- unsigned int start_block;
- unsigned int file_size:32;
- unsigned short block_list[0];
-} __attribute__ ((packed));
-
-struct squashfs_dir_inode_header_1 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:4; /* index into uid table */
- unsigned int guid:4; /* index into guid table */
- unsigned int file_size:19;
- unsigned int offset:13;
- unsigned int mtime;
- unsigned int start_block:24;
-} __attribute__ ((packed));
-
-union squashfs_inode_header_1 {
- struct squashfs_base_inode_header_1 base;
- struct squashfs_dev_inode_header_1 dev;
- struct squashfs_symlink_inode_header_1 symlink;
- struct squashfs_reg_inode_header_1 reg;
- struct squashfs_dir_inode_header_1 dir;
- struct squashfs_ipc_inode_header_1 ipc;
-};
-
-#define SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n) \
- SQUASHFS_MEMSET(s, d, n);\
- SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
- SQUASHFS_SWAP((s)->mode, d, 4, 12);\
- SQUASHFS_SWAP((s)->uid, d, 16, 4);\
- SQUASHFS_SWAP((s)->guid, d, 20, 4);
-
-#define SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, n) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n)\
-}
-
-#define SQUASHFS_SWAP_IPC_INODE_HEADER_1(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
- sizeof(struct squashfs_ipc_inode_header_1));\
- SQUASHFS_SWAP((s)->type, d, 24, 4);\
- SQUASHFS_SWAP((s)->offset, d, 28, 4);\
-}
-
-#define SQUASHFS_SWAP_DEV_INODE_HEADER_1(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
- sizeof(struct squashfs_dev_inode_header_1));\
- SQUASHFS_SWAP((s)->rdev, d, 24, 16);\
-}
-
-#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
- sizeof(struct squashfs_symlink_inode_header_1));\
- SQUASHFS_SWAP((s)->symlink_size, d, 24, 16);\
-}
-
-#define SQUASHFS_SWAP_REG_INODE_HEADER_1(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
- sizeof(struct squashfs_reg_inode_header_1));\
- SQUASHFS_SWAP((s)->mtime, d, 24, 32);\
- SQUASHFS_SWAP((s)->start_block, d, 56, 32);\
- SQUASHFS_SWAP((s)->file_size, d, 88, 32);\
-}
-
-#define SQUASHFS_SWAP_DIR_INODE_HEADER_1(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
- sizeof(struct squashfs_dir_inode_header_1));\
- SQUASHFS_SWAP((s)->file_size, d, 24, 19);\
- SQUASHFS_SWAP((s)->offset, d, 43, 13);\
- SQUASHFS_SWAP((s)->mtime, d, 56, 32);\
- SQUASHFS_SWAP((s)->start_block, d, 88, 24);\
-}
-
-#endif
-
-#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY
-
-struct squashfs_dir_index_2 {
- unsigned int index:27;
- unsigned int start_block:29;
- unsigned char size;
- unsigned char name[0];
-} __attribute__ ((packed));
-
-struct squashfs_base_inode_header_2 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:8; /* index into uid table */
- unsigned int guid:8; /* index into guid table */
-} __attribute__ ((packed));
-
-struct squashfs_ipc_inode_header_2 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:8; /* index into uid table */
- unsigned int guid:8; /* index into guid table */
-} __attribute__ ((packed));
-
-struct squashfs_dev_inode_header_2 {
- 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));
-
-struct squashfs_symlink_inode_header_2 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:8; /* index into uid table */
- unsigned int guid:8; /* index into guid table */
- unsigned short symlink_size;
- char symlink[0];
-} __attribute__ ((packed));
-
-struct squashfs_reg_inode_header_2 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:8; /* index into uid table */
- unsigned int guid:8; /* index into guid table */
- unsigned int mtime;
- unsigned int start_block;
- unsigned int fragment;
- unsigned int offset;
- unsigned int file_size:32;
- unsigned short block_list[0];
-} __attribute__ ((packed));
-
-struct squashfs_dir_inode_header_2 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:8; /* index into uid table */
- unsigned int guid:8; /* index into guid table */
- unsigned int file_size:19;
- unsigned int offset:13;
- unsigned int mtime;
- unsigned int start_block:24;
-} __attribute__ ((packed));
-
-struct squashfs_ldir_inode_header_2 {
- unsigned int inode_type:4;
- unsigned int mode:12; /* protection */
- unsigned int uid:8; /* index into uid table */
- unsigned int guid:8; /* index into guid table */
- unsigned int file_size:27;
- unsigned int offset:13;
- unsigned int mtime;
- unsigned int start_block:24;
- unsigned int i_count:16;
- struct squashfs_dir_index_2 index[0];
-} __attribute__ ((packed));
-
-union squashfs_inode_header_2 {
- struct squashfs_base_inode_header_2 base;
- struct squashfs_dev_inode_header_2 dev;
- struct squashfs_symlink_inode_header_2 symlink;
- struct squashfs_reg_inode_header_2 reg;
- struct squashfs_dir_inode_header_2 dir;
- struct squashfs_ldir_inode_header_2 ldir;
- struct squashfs_ipc_inode_header_2 ipc;
-};
-
-struct squashfs_dir_header_2 {
- unsigned int count:8;
- unsigned int start_block:24;
-} __attribute__ ((packed));
-
-struct squashfs_dir_entry_2 {
- unsigned int offset:13;
- unsigned int type:3;
- unsigned int size:8;
- char name[0];
-} __attribute__ ((packed));
-
-struct squashfs_fragment_entry_2 {
- unsigned int start_block;
- unsigned int size;
-} __attribute__ ((packed));
-
-#define SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\
- SQUASHFS_MEMSET(s, d, n);\
- SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
- SQUASHFS_SWAP((s)->mode, d, 4, 12);\
- SQUASHFS_SWAP((s)->uid, d, 16, 8);\
- SQUASHFS_SWAP((s)->guid, d, 24, 8);\
-
-#define SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, n) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\
-}
-
-#define SQUASHFS_SWAP_IPC_INODE_HEADER_2(s, d) \
- SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, sizeof(struct squashfs_ipc_inode_header_2))
-
-#define SQUASHFS_SWAP_DEV_INODE_HEADER_2(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
- sizeof(struct squashfs_dev_inode_header_2)); \
- SQUASHFS_SWAP((s)->rdev, d, 32, 16);\
-}
-
-#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
- sizeof(struct squashfs_symlink_inode_header_2));\
- SQUASHFS_SWAP((s)->symlink_size, d, 32, 16);\
-}
-
-#define SQUASHFS_SWAP_REG_INODE_HEADER_2(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
- sizeof(struct squashfs_reg_inode_header_2));\
- SQUASHFS_SWAP((s)->mtime, d, 32, 32);\
- SQUASHFS_SWAP((s)->start_block, d, 64, 32);\
- SQUASHFS_SWAP((s)->fragment, d, 96, 32);\
- SQUASHFS_SWAP((s)->offset, d, 128, 32);\
- SQUASHFS_SWAP((s)->file_size, d, 160, 32);\
-}
-
-#define SQUASHFS_SWAP_DIR_INODE_HEADER_2(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
- sizeof(struct squashfs_dir_inode_header_2));\
- SQUASHFS_SWAP((s)->file_size, d, 32, 19);\
- SQUASHFS_SWAP((s)->offset, d, 51, 13);\
- SQUASHFS_SWAP((s)->mtime, d, 64, 32);\
- SQUASHFS_SWAP((s)->start_block, d, 96, 24);\
-}
-
-#define SQUASHFS_SWAP_LDIR_INODE_HEADER_2(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
- sizeof(struct squashfs_ldir_inode_header_2));\
- SQUASHFS_SWAP((s)->file_size, d, 32, 27);\
- SQUASHFS_SWAP((s)->offset, d, 59, 13);\
- SQUASHFS_SWAP((s)->mtime, d, 72, 32);\
- SQUASHFS_SWAP((s)->start_block, d, 104, 24);\
- SQUASHFS_SWAP((s)->i_count, d, 128, 16);\
-}
-
-#define SQUASHFS_SWAP_DIR_INDEX_2(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index_2));\
- SQUASHFS_SWAP((s)->index, d, 0, 27);\
- SQUASHFS_SWAP((s)->start_block, d, 27, 29);\
- SQUASHFS_SWAP((s)->size, d, 56, 8);\
-}
-#define SQUASHFS_SWAP_DIR_HEADER_2(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header_2));\
- SQUASHFS_SWAP((s)->count, d, 0, 8);\
- SQUASHFS_SWAP((s)->start_block, d, 8, 24);\
-}
-
-#define SQUASHFS_SWAP_DIR_ENTRY_2(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry_2));\
- SQUASHFS_SWAP((s)->offset, d, 0, 13);\
- SQUASHFS_SWAP((s)->type, d, 13, 3);\
- SQUASHFS_SWAP((s)->size, d, 16, 8);\
-}
-
-#define SQUASHFS_SWAP_FRAGMENT_ENTRY_2(s, d) {\
- SQUASHFS_SWAP_START\
- SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry_2));\
- SQUASHFS_SWAP((s)->start_block, d, 0, 32);\
- SQUASHFS_SWAP((s)->size, d, 32, 32);\
-}
-
-#define SQUASHFS_SWAP_FRAGMENT_INDEXES_2(s, d, n) SQUASHFS_SWAP_INTS(s, d, n)
-
-/* fragment and fragment table defines */
-#define SQUASHFS_FRAGMENT_BYTES_2(A) (A * sizeof(struct squashfs_fragment_entry_2))
-
-#define SQUASHFS_FRAGMENT_INDEX_2(A) (SQUASHFS_FRAGMENT_BYTES_2(A) / \
- SQUASHFS_METADATA_SIZE)
-
-#define SQUASHFS_FRAGMENT_INDEX_OFFSET_2(A) (SQUASHFS_FRAGMENT_BYTES_2(A) % \
- SQUASHFS_METADATA_SIZE)
-
-#define SQUASHFS_FRAGMENT_INDEXES_2(A) ((SQUASHFS_FRAGMENT_BYTES_2(A) + \
- SQUASHFS_METADATA_SIZE - 1) / \
- SQUASHFS_METADATA_SIZE)
-
-#define SQUASHFS_FRAGMENT_INDEX_BYTES_2(A) (SQUASHFS_FRAGMENT_INDEXES_2(A) *\
- sizeof(int))
-
-#endif
#ifdef __KERNEL__
--
With kind regards,
Geert Uytterhoeven
Software Architect
Sony Techsoft Centre
The Corporate Village · Da Vincilaan 7-D1 · B-1935 Zaventem · Belgium
Phone: +32 (0)2 700 8453
Fax: +32 (0)2 700 8622
E-mail: Gee...@so...
Internet: http://www.sony-europe.com/
Sony Technology and Software Centre Europe
A division of Sony Service Centre (Europe) N.V.
Registered office: Technologielaan 7 · B-1840 Londerzeel · Belgium
VAT BE 0413.825.160 · RPR Brussels
Fortis 293-0376800-10 GEBA-BE-BB
|