/* * cramfs.c * * Copyright (C) 1999 Linus Torvalds * * Copyright (C) 2000-2002 Transmeta Corporation * * Copyright (C) 2003 Kai-Uwe Bloem, * Auerswald GmbH & Co KG, <linux-development@auerswald.de> * - adapted from the www.tuxbox.org u-boot tree, added "ls" command * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License (Version 2) as * published by the Free Software Foundation. * * Compressed ROM filesystem for Linux. * * TODO: * add support for resolving symbolic links *//* * These are the VFS interfaces to the compressed ROM filesystem. * The actual compression is based on zlib, see the other files. */#include <common.h>#include <malloc.h>#include <asm/byteorder.h>#include <linux/stat.h>#include <jffs2/jffs2.h>#include <jffs2/load_kernel.h>#include <cramfs/cramfs_fs.h>/* These two macros may change in future, to provide better st_ino   semantics. */#define CRAMINO(x)	(CRAMFS_GET_OFFSET(x) ? CRAMFS_GET_OFFSET(x)<<2 : 1)#define OFFSET(x)	((x)->i_ino)struct cramfs_super super;/* CPU address space offset calculation macro, struct part_info offset is * device address space offset, so we need to shift it by a device start address. */extern flash_info_t flash_info[];#define PART_OFFSET(x)	(x->offset + flash_info[x->dev->id->num].start[0])static int cramfs_read_super (struct part_info *info){	unsigned long root_offset;	/* Read the first block and get the superblock from it */	memcpy (&super, (void *) PART_OFFSET(info), sizeof (super));	/* Do sanity checks on the superblock */	if (super.magic != CRAMFS_32 (CRAMFS_MAGIC)) {		/* check at 512 byte offset */		memcpy (&super, (void *) PART_OFFSET(info) + 512, sizeof (super));		if (super.magic != CRAMFS_32 (CRAMFS_MAGIC)) {			printf ("cramfs: wrong magic\n");			return -1;		}	}	/* flags is reused several times, so swab it once */	super.flags = CRAMFS_32 (super.flags);	super.size = CRAMFS_32 (super.size);	/* get feature flags first */	if (super.flags & ~CRAMFS_SUPPORTED_FLAGS) {		printf ("cramfs: unsupported filesystem features\n");		return -1;	}	/* Check that the root inode is in a sane state */	if (!S_ISDIR (CRAMFS_16 (super.root.mode))) {		printf ("cramfs: root is not a directory\n");		return -1;	}	root_offset = CRAMFS_GET_OFFSET (&(super.root)) << 2;	if (root_offset == 0) {		printf ("cramfs: empty filesystem");	} else if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) &&		   ((root_offset != sizeof (struct cramfs_super)) &&		    (root_offset != 512 + sizeof (struct cramfs_super)))) {		printf ("cramfs: bad root offset %lu\n", root_offset);		return -1;	}	return 0;}static unsigned long cramfs_resolve (unsigned long begin, unsigned long offset,				     unsigned long size, int raw,				     char *filename){	unsigned long inodeoffset = 0, nextoffset;	while (inodeoffset < size) {		struct cramfs_inode *inode;		char *name;		int namelen;		inode = (struct cramfs_inode *) (begin + offset +						 inodeoffset);		/*		 * Namelengths on disk are shifted by two		 * and the name padded out to 4-byte boundaries		 * with zeroes.		 */		namelen = CRAMFS_GET_NAMELEN (inode) << 2;		name = (char *) inode + sizeof (struct cramfs_inode);		nextoffset =			inodeoffset + sizeof (struct cramfs_inode) + namelen;		for (;;) {			if (!namelen)				return -1;			if (name[namelen - 1])				break;			namelen--;		}		if (!strncmp (filename, name, namelen)) {			char *p = strtok (NULL, "/");			if (raw && (p == NULL || *p == '\0'))				return offset + inodeoffset;			if (S_ISDIR (CRAMFS_16 (inode->mode))) {				return cramfs_resolve (begin,						       CRAMFS_GET_OFFSET						       (inode) << 2,						       CRAMFS_24 (inode->								  size), raw,						       p);			} else if (S_ISREG (CRAMFS_16 (inode->mode))) {				return offset + inodeoffset;			} else {				printf ("%*.*s: unsupported file type (%x)\n",					namelen, namelen, name,					CRAMFS_16 (inode->mode));				return 0;			}		}		inodeoffset = nextoffset;	}	printf ("can't find corresponding entry\n");	return 0;}static int cramfs_uncompress (unsigned long begin, unsigned long offset,			      unsigned long loadoffset){	struct cramfs_inode *inode = (struct cramfs_inode *) (begin + offset);	unsigned long *block_ptrs = (unsigned long *)		(begin + (CRAMFS_GET_OFFSET (inode) << 2));	unsigned long curr_block = (CRAMFS_GET_OFFSET (inode) +				    (((CRAMFS_24 (inode->size)) +				      4095) >> 12)) << 2;	int size, total_size = 0;	int i;	cramfs_uncompress_init ();	for (i = 0; i < ((CRAMFS_24 (inode->size) + 4095) >> 12); i++) {		size = cramfs_uncompress_block ((void *) loadoffset,						(void *) (begin + curr_block),						(CRAMFS_32 (block_ptrs[i]) -						 curr_block));		if (size < 0)			return size;		loadoffset += size;		total_size += size;		curr_block = CRAMFS_32 (block_ptrs[i]);	}	cramfs_uncompress_exit ();	return total_size;}int cramfs_load (char *loadoffset, struct part_info *info, char *filename){	unsigned long offset;	if (cramfs_read_super (info))		return -1;	offset = cramfs_resolve (PART_OFFSET(info),				 CRAMFS_GET_OFFSET (&(super.root)) << 2,				 CRAMFS_24 (super.root.size), 0,				 strtok (filename, "/"));	if (offset <= 0)		return offset;	return cramfs_uncompress (PART_OFFSET(info), offset,				  (unsigned long) loadoffset);}static int cramfs_list_inode (struct part_info *info, unsigned long offset){	struct cramfs_inode *inode = (struct cramfs_inode *)		(PART_OFFSET(info) + offset);	char *name, str[20];	int namelen, nextoff;	/*	 * Namelengths on disk are shifted by two	 * and the name padded out to 4-byte boundaries	 * with zeroes.	 */	namelen = CRAMFS_GET_NAMELEN (inode) << 2;	name = (char *) inode + sizeof (struct cramfs_inode);	nextoff = namelen;	for (;;) {		if (!namelen)			return namelen;		if (name[namelen - 1])			break;		namelen--;	}	printf (" %s %8d %*.*s", mkmodestr (CRAMFS_16 (inode->mode), str),		CRAMFS_24 (inode->size), namelen, namelen, name);	if ((CRAMFS_16 (inode->mode) & S_IFMT) == S_IFLNK) {		/* symbolic link.		 * Unpack the link target, trusting in the inode's size field.		 */		unsigned long size = CRAMFS_24 (inode->size);		char *link = malloc (size);		if (link != NULL && cramfs_uncompress (PART_OFFSET(info), offset,						       (unsigned long) link)		    == size)			printf (" -> %*.*s\n", (int) size, (int) size, link);		else			printf (" [Error reading link]\n");		if (link)			free (link);	} else		printf ("\n");	return nextoff;}int cramfs_ls (struct part_info *info, char *filename){	struct cramfs_inode *inode;	unsigned long inodeoffset = 0, nextoffset;	unsigned long offset, size;	if (cramfs_read_super (info))		return -1;	if (strlen (filename) == 0 || !strcmp (filename, "/")) {		/* Root directory. Use root inode in super block */		offset = CRAMFS_GET_OFFSET (&(super.root)) << 2;		size = CRAMFS_24 (super.root.size);	} else {		/* Resolve the path */		offset = cramfs_resolve (PART_OFFSET(info),					 CRAMFS_GET_OFFSET (&(super.root)) <<					 2, CRAMFS_24 (super.root.size), 1,					 strtok (filename, "/"));		if (offset <= 0)			return offset;		/* Resolving was successful. Examine the inode */		inode = (struct cramfs_inode *) (PART_OFFSET(info) + offset);		if (!S_ISDIR (CRAMFS_16 (inode->mode))) {			/* It's not a directory - list it, and that's that */			return (cramfs_list_inode (info, offset) > 0);		}		/* It's a directory. List files within */		offset = CRAMFS_GET_OFFSET (inode) << 2;		size = CRAMFS_24 (inode->size);	}	/* List the given directory */	while (inodeoffset < size) {		inode = (struct cramfs_inode *) (PART_OFFSET(info) + offset +						 inodeoffset);		nextoffset = cramfs_list_inode (info, offset + inodeoffset);		if (nextoffset == 0)			break;		inodeoffset += sizeof (struct cramfs_inode) + nextoffset;	}	return 1;}int cramfs_info (struct part_info *info){	if (cramfs_read_super (info))		return 0;	printf ("size: 0x%x (%u)\n", super.size, super.size);	if (super.flags != 0) {		printf ("flags:\n");		if (super.flags & CRAMFS_FLAG_FSID_VERSION_2)			printf ("\tFSID version 2\n");		if (super.flags & CRAMFS_FLAG_SORTED_DIRS)			printf ("\tsorted dirs\n");		if (super.flags & CRAMFS_FLAG_HOLES)			printf ("\tholes\n");		if (super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET)			printf ("\tshifted root offset\n");	}	printf ("fsid:\n\tcrc: 0x%x\n\tedition: 0x%x\n",		super.fsid.crc, super.fsid.edition);	printf ("name: %16s\n", super.name);	return 1;}int cramfs_check (struct part_info *info){	struct cramfs_super *sb;	if (info->dev->id->type != MTD_DEV_TYPE_NOR)		return 0;	sb = (struct cramfs_super *) PART_OFFSET(info);	if (sb->magic != CRAMFS_32 (CRAMFS_MAGIC)) {		/* check at 512 byte offset */		sb = (struct cramfs_super *) (PART_OFFSET(info) + 512);		if (sb->magic != CRAMFS_32 (CRAMFS_MAGIC))			return 0;	}	return 1;}