fs/cramfs/cramfs.c - platform/external/u-boot - Gitiles

 /*
  * 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>

 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) || defined(CONFIG_CMD_JFFS2)

 #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;
 }

 #endif /* CFG_FS_CRAMFS */
	/*
	* 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>

	#if (CONFIG_COMMANDS & CFG_CMD_JFFS2) \|\| defined(CONFIG_CMD_JFFS2)

	#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;
	}

	#endif /* CFG_FS_CRAMFS */