[u-boot.git] / fs / ubifs / ubifs.c

/*
 * This file is part of UBIFS.
 *
 * Copyright (C) 2006-2008 Nokia Corporation.
 *
 * (C) Copyright 2008-2010
 * Stefan Roese, DENX Software Engineering, [email protected].
 *
 * 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.
 *
 * 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, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * Authors: Artem Bityutskiy (Битюцкий Артём)
 *          Adrian Hunter
 */

#include "ubifs.h"
#include <u-boot/zlib.h>

DECLARE_GLOBAL_DATA_PTR;

/* compress.c */

/*
 * We need a wrapper for zunzip() because the parameters are
 * incompatible with the lzo decompressor.
 */
static int gzip_decompress(const unsigned char *in, size_t in_len,
			   unsigned char *out, size_t *out_len)
{
	return zunzip(out, *out_len, (unsigned char *)in,
		      (unsigned long *)out_len, 0, 0);
}

/* Fake description object for the "none" compressor */
static struct ubifs_compressor none_compr = {
	.compr_type = UBIFS_COMPR_NONE,
	.name = "no compression",
	.capi_name = "",
	.decompress = NULL,
};

static struct ubifs_compressor lzo_compr = {
	.compr_type = UBIFS_COMPR_LZO,
	.name = "LZO",
	.capi_name = "lzo",
	.decompress = lzo1x_decompress_safe,
};

static struct ubifs_compressor zlib_compr = {
	.compr_type = UBIFS_COMPR_ZLIB,
	.name = "zlib",
	.capi_name = "deflate",
	.decompress = gzip_decompress,
};

/* All UBIFS compressors */
struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];

/**
 * ubifs_decompress - decompress data.
 * @in_buf: data to decompress
 * @in_len: length of the data to decompress
 * @out_buf: output buffer where decompressed data should
 * @out_len: output length is returned here
 * @compr_type: type of compression
 *
 * This function decompresses data from buffer @in_buf into buffer @out_buf.
 * The length of the uncompressed data is returned in @out_len. This functions
 * returns %0 on success or a negative error code on failure.
 */
int ubifs_decompress(const void *in_buf, int in_len, void *out_buf,
		     int *out_len, int compr_type)
{
	int err;
	struct ubifs_compressor *compr;

	if (unlikely(compr_type < 0 || compr_type >= UBIFS_COMPR_TYPES_CNT)) {
		ubifs_err("invalid compression type %d", compr_type);
		return -EINVAL;
	}

	compr = ubifs_compressors[compr_type];

	if (unlikely(!compr->capi_name)) {
		ubifs_err("%s compression is not compiled in", compr->name);
		return -EINVAL;
	}

	if (compr_type == UBIFS_COMPR_NONE) {
		memcpy(out_buf, in_buf, in_len);
		*out_len = in_len;
		return 0;
	}

	err = compr->decompress(in_buf, in_len, out_buf, (size_t *)out_len);
	if (err)
		ubifs_err("cannot decompress %d bytes, compressor %s, "
			  "error %d", in_len, compr->name, err);

	return err;
}

/**
 * compr_init - initialize a compressor.
 * @compr: compressor description object
 *
 * This function initializes the requested compressor and returns zero in case
 * of success or a negative error code in case of failure.
 */
static int __init compr_init(struct ubifs_compressor *compr)
{
	ubifs_compressors[compr->compr_type] = compr;

#ifdef CONFIG_NEEDS_MANUAL_RELOC
	ubifs_compressors[compr->compr_type]->name += gd->reloc_off;
	ubifs_compressors[compr->compr_type]->capi_name += gd->reloc_off;
	ubifs_compressors[compr->compr_type]->decompress += gd->reloc_off;
#endif

	return 0;
}

/**
 * ubifs_compressors_init - initialize UBIFS compressors.
 *
 * This function initializes the compressor which were compiled in. Returns
 * zero in case of success and a negative error code in case of failure.
 */
int __init ubifs_compressors_init(void)
{
	int err;

	err = compr_init(&lzo_compr);
	if (err)
		return err;

	err = compr_init(&zlib_compr);
	if (err)
		return err;

	err = compr_init(&none_compr);
	if (err)
		return err;

	return 0;
}

/*
 * ubifsls...
 */

static int filldir(struct ubifs_info *c, const char *name, int namlen,
		   u64 ino, unsigned int d_type)
{
	struct inode *inode;
	char filetime[32];

	switch (d_type) {
	case UBIFS_ITYPE_REG:
		printf("\t");
		break;
	case UBIFS_ITYPE_DIR:
		printf("<DIR>\t");
		break;
	case UBIFS_ITYPE_LNK:
		printf("<LNK>\t");
		break;
	default:
		printf("other\t");
		break;
	}

	inode = ubifs_iget(c->vfs_sb, ino);
	if (IS_ERR(inode)) {
		printf("%s: Error in ubifs_iget(), ino=%lld ret=%p!\n",
		       __func__, ino, inode);
		return -1;
	}
	ctime_r((time_t *)&inode->i_mtime, filetime);
	printf("%9lld  %24.24s  ", inode->i_size, filetime);
	ubifs_iput(inode);

	printf("%s\n", name);

	return 0;
}

static int ubifs_printdir(struct file *file, void *dirent)
{
	int err, over = 0;
	struct qstr nm;
	union ubifs_key key;
	struct ubifs_dent_node *dent;
	struct inode *dir = file->f_path.dentry->d_inode;
	struct ubifs_info *c = dir->i_sb->s_fs_info;

	dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);

	if (file->f_pos > UBIFS_S_KEY_HASH_MASK || file->f_pos == 2)
		/*
		 * The directory was seek'ed to a senseless position or there
		 * are no more entries.
		 */
		return 0;

	if (file->f_pos == 1) {
		/* Find the first entry in TNC and save it */
		lowest_dent_key(c, &key, dir->i_ino);
		nm.name = NULL;
		dent = ubifs_tnc_next_ent(c, &key, &nm);
		if (IS_ERR(dent)) {
			err = PTR_ERR(dent);
			goto out;
		}

		file->f_pos = key_hash_flash(c, &dent->key);
		file->private_data = dent;
	}

	dent = file->private_data;
	if (!dent) {
		/*
		 * The directory was seek'ed to and is now readdir'ed.
		 * Find the entry corresponding to @file->f_pos or the
		 * closest one.
		 */
		dent_key_init_hash(c, &key, dir->i_ino, file->f_pos);
		nm.name = NULL;
		dent = ubifs_tnc_next_ent(c, &key, &nm);
		if (IS_ERR(dent)) {
			err = PTR_ERR(dent);
			goto out;
		}
		file->f_pos = key_hash_flash(c, &dent->key);
		file->private_data = dent;
	}

	while (1) {
		dbg_gen("feed '%s', ino %llu, new f_pos %#x",
			dent->name, (unsigned long long)le64_to_cpu(dent->inum),
			key_hash_flash(c, &dent->key));
		ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);

		nm.len = le16_to_cpu(dent->nlen);
		over = filldir(c, (char *)dent->name, nm.len,
			       le64_to_cpu(dent->inum), dent->type);
		if (over)
			return 0;

		/* Switch to the next entry */
		key_read(c, &dent->key, &key);
		nm.name = (char *)dent->name;
		dent = ubifs_tnc_next_ent(c, &key, &nm);
		if (IS_ERR(dent)) {
			err = PTR_ERR(dent);
			goto out;
		}

		kfree(file->private_data);
		file->f_pos = key_hash_flash(c, &dent->key);
		file->private_data = dent;
		cond_resched();
	}

out:
	if (err != -ENOENT) {
		ubifs_err("cannot find next direntry, error %d", err);
		return err;
	}

	kfree(file->private_data);
	file->private_data = NULL;
	file->f_pos = 2;
	return 0;
}

static int ubifs_finddir(struct super_block *sb, char *dirname,
			 unsigned long root_inum, unsigned long *inum)
{
	int err;
	struct qstr nm;
	union ubifs_key key;
	struct ubifs_dent_node *dent;
	struct ubifs_info *c;
	struct file *file;
	struct dentry *dentry;
	struct inode *dir;
	int ret = 0;

	file = kzalloc(sizeof(struct file), 0);
	dentry = kzalloc(sizeof(struct dentry), 0);
	dir = kzalloc(sizeof(struct inode), 0);
	if (!file || !dentry || !dir) {
		printf("%s: Error, no memory for malloc!\n", __func__);
		err = -ENOMEM;
		goto out;
	}

	dir->i_sb = sb;
	file->f_path.dentry = dentry;
	file->f_path.dentry->d_parent = dentry;
	file->f_path.dentry->d_inode = dir;
	file->f_path.dentry->d_inode->i_ino = root_inum;
	c = sb->s_fs_info;

	dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);

	/* Find the first entry in TNC and save it */
	lowest_dent_key(c, &key, dir->i_ino);
	nm.name = NULL;
	dent = ubifs_tnc_next_ent(c, &key, &nm);
	if (IS_ERR(dent)) {
		err = PTR_ERR(dent);
		goto out;
	}

	file->f_pos = key_hash_flash(c, &dent->key);
	file->private_data = dent;

	while (1) {
		dbg_gen("feed '%s', ino %llu, new f_pos %#x",
			dent->name, (unsigned long long)le64_to_cpu(dent->inum),
			key_hash_flash(c, &dent->key));
		ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);

		nm.len = le16_to_cpu(dent->nlen);
		if ((strncmp(dirname, (char *)dent->name, nm.len) == 0) &&
		    (strlen(dirname) == nm.len)) {
			*inum = le64_to_cpu(dent->inum);
			ret = 1;
			goto out_free;
		}

		/* Switch to the next entry */
		key_read(c, &dent->key, &key);
		nm.name = (char *)dent->name;
		dent = ubifs_tnc_next_ent(c, &key, &nm);
		if (IS_ERR(dent)) {
			err = PTR_ERR(dent);
			goto out;
		}

		kfree(file->private_data);
		file->f_pos = key_hash_flash(c, &dent->key);
		file->private_data = dent;
		cond_resched();
	}

out:
	if (err != -ENOENT)
		ubifs_err("cannot find next direntry, error %d", err);

out_free:
	if (file->private_data)
		kfree(file->private_data);
	if (file)
		free(file);
	if (dentry)
		free(dentry);
	if (dir)
		free(dir);

	return ret;
}

static unsigned long ubifs_findfile(struct super_block *sb, char *filename)
{
	int ret;
	char *next;
	char fpath[128];
	char symlinkpath[128];
	char *name = fpath;
	unsigned long root_inum = 1;
	unsigned long inum;
	int symlink_count = 0; /* Don't allow symlink recursion */
	char link_name[64];

	strcpy(fpath, filename);

	/* Remove all leading slashes */
	while (*name == '/')
		name++;

	/*
	 * Handle root-direcoty ('/')
	 */
	inum = root_inum;
	if (!name || *name == '\0')
		return inum;

	for (;;) {
		struct inode *inode;
		struct ubifs_inode *ui;

		/* Extract the actual part from the pathname.  */
		next = strchr(name, '/');
		if (next) {
			/* Remove all leading slashes.  */
			while (*next == '/')
				*(next++) = '\0';
		}

		ret = ubifs_finddir(sb, name, root_inum, &inum);
		if (!ret)
			return 0;
		inode = ubifs_iget(sb, inum);

		if (!inode)
			return 0;
		ui = ubifs_inode(inode);

		if ((inode->i_mode & S_IFMT) == S_IFLNK) {
			char buf[128];

			/* We have some sort of symlink recursion, bail out */
			if (symlink_count++ > 8) {
				printf("Symlink recursion, aborting\n");
				return 0;
			}
			memcpy(link_name, ui->data, ui->data_len);
			link_name[ui->data_len] = '\0';

			if (link_name[0] == '/') {
				/* Absolute path, redo everything without
				 * the leading slash */
				next = name = link_name + 1;
				root_inum = 1;
				continue;
			}
			/* Relative to cur dir */
			sprintf(buf, "%s/%s",
					link_name, next == NULL ? "" : next);
			memcpy(symlinkpath, buf, sizeof(buf));
			next = name = symlinkpath;
			continue;
		}

		/*
		 * Check if directory with this name exists
		 */

		/* Found the node!  */
		if (!next || *next == '\0')
			return inum;

		root_inum = inum;
		name = next;
	}

	return 0;
}

int ubifs_ls(char *filename)
{
	struct ubifs_info *c = ubifs_sb->s_fs_info;
	struct file *file;
	struct dentry *dentry;
	struct inode *dir;
	void *dirent = NULL;
	unsigned long inum;
	int ret = 0;

	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
	inum = ubifs_findfile(ubifs_sb, filename);
	if (!inum) {
		ret = -1;
		goto out;
	}

	file = kzalloc(sizeof(struct file), 0);
	dentry = kzalloc(sizeof(struct dentry), 0);
	dir = kzalloc(sizeof(struct inode), 0);
	if (!file || !dentry || !dir) {
		printf("%s: Error, no memory for malloc!\n", __func__);
		ret = -ENOMEM;
		goto out_mem;
	}

	dir->i_sb = ubifs_sb;
	file->f_path.dentry = dentry;
	file->f_path.dentry->d_parent = dentry;
	file->f_path.dentry->d_inode = dir;
	file->f_path.dentry->d_inode->i_ino = inum;
	file->f_pos = 1;
	file->private_data = NULL;
	ubifs_printdir(file, dirent);

out_mem:
	if (file)
		free(file);
	if (dentry)
		free(dentry);
	if (dir)
		free(dir);

out:
	ubi_close_volume(c->ubi);
	return ret;
}

/*
 * ubifsload...
 */

/* file.c */

static inline void *kmap(struct page *page)
{
	return page->addr;
}

static int read_block(struct inode *inode, void *addr, unsigned int block,
		      struct ubifs_data_node *dn)
{
	struct ubifs_info *c = inode->i_sb->s_fs_info;
	int err, len, out_len;
	union ubifs_key key;
	unsigned int dlen;

	data_key_init(c, &key, inode->i_ino, block);
	err = ubifs_tnc_lookup(c, &key, dn);
	if (err) {
		if (err == -ENOENT)
			/* Not found, so it must be a hole */
			memset(addr, 0, UBIFS_BLOCK_SIZE);
		return err;
	}

	ubifs_assert(le64_to_cpu(dn->ch.sqnum) > ubifs_inode(inode)->creat_sqnum);

	len = le32_to_cpu(dn->size);
	if (len <= 0 || len > UBIFS_BLOCK_SIZE)
		goto dump;

	dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
	out_len = UBIFS_BLOCK_SIZE;
	err = ubifs_decompress(&dn->data, dlen, addr, &out_len,
			       le16_to_cpu(dn->compr_type));
	if (err || len != out_len)
		goto dump;

	/*
	 * Data length can be less than a full block, even for blocks that are
	 * not the last in the file (e.g., as a result of making a hole and
	 * appending data). Ensure that the remainder is zeroed out.
	 */
	if (len < UBIFS_BLOCK_SIZE)
		memset(addr + len, 0, UBIFS_BLOCK_SIZE - len);

	return 0;

dump:
	ubifs_err("bad data node (block %u, inode %lu)",
		  block, inode->i_ino);
	dbg_dump_node(c, dn);
	return -EINVAL;
}

static int do_readpage(struct ubifs_info *c, struct inode *inode,
		       struct page *page, int last_block_size)
{
	void *addr;
	int err = 0, i;
	unsigned int block, beyond;
	struct ubifs_data_node *dn;
	loff_t i_size = inode->i_size;

	dbg_gen("ino %lu, pg %lu, i_size %lld",
		inode->i_ino, page->index, i_size);

	addr = kmap(page);

	block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;
	beyond = (i_size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
	if (block >= beyond) {
		/* Reading beyond inode */
		memset(addr, 0, PAGE_CACHE_SIZE);
		goto out;
	}

	dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS);
	if (!dn)
		return -ENOMEM;

	i = 0;
	while (1) {
		int ret;

		if (block >= beyond) {
			/* Reading beyond inode */
			err = -ENOENT;
			memset(addr, 0, UBIFS_BLOCK_SIZE);
		} else {
			/*
			 * Reading last block? Make sure to not write beyond
			 * the requested size in the destination buffer.
			 */
			if (((block + 1) == beyond) || last_block_size) {
				void *buff;
				int dlen;

				/*
				 * We need to buffer the data locally for the
				 * last block. This is to not pad the
				 * destination area to a multiple of
				 * UBIFS_BLOCK_SIZE.
				 */
				buff = malloc(UBIFS_BLOCK_SIZE);
				if (!buff) {
					printf("%s: Error, malloc fails!\n",
					       __func__);
					err = -ENOMEM;
					break;
				}

				/* Read block-size into temp buffer */
				ret = read_block(inode, buff, block, dn);
				if (ret) {
					err = ret;
					if (err != -ENOENT) {
						free(buff);
						break;
					}
				}

				if (last_block_size)
					dlen = last_block_size;
				else
					dlen = le32_to_cpu(dn->size);

				/* Now copy required size back to dest */
				memcpy(addr, buff, dlen);

				free(buff);
			} else {
				ret = read_block(inode, addr, block, dn);
				if (ret) {
					err = ret;
					if (err != -ENOENT)
						break;
				}
			}
		}
		if (++i >= UBIFS_BLOCKS_PER_PAGE)
			break;
		block += 1;
		addr += UBIFS_BLOCK_SIZE;
	}
	if (err) {
		if (err == -ENOENT) {
			/* Not found, so it must be a hole */
			dbg_gen("hole");
			goto out_free;
		}
		ubifs_err("cannot read page %lu of inode %lu, error %d",
			  page->index, inode->i_ino, err);
		goto error;
	}

out_free:
	kfree(dn);
out:
	return 0;

error:
	kfree(dn);
	return err;
}

int ubifs_load(char *filename, u32 addr, u32 size)
{
	struct ubifs_info *c = ubifs_sb->s_fs_info;
	unsigned long inum;
	struct inode *inode;
	struct page page;
	int err = 0;
	int i;
	int count;
	int last_block_size = 0;
	char buf [10];

	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
	/* ubifs_findfile will resolve symlinks, so we know that we get
	 * the real file here */
	inum = ubifs_findfile(ubifs_sb, filename);
	if (!inum) {
		err = -1;
		goto out;
	}

	/*
	 * Read file inode
	 */
	inode = ubifs_iget(ubifs_sb, inum);
	if (IS_ERR(inode)) {
		printf("%s: Error reading inode %ld!\n", __func__, inum);
		err = PTR_ERR(inode);
		goto out;
	}

	/*
	 * If no size was specified or if size bigger than filesize
	 * set size to filesize
	 */
	if ((size == 0) || (size > inode->i_size))
		size = inode->i_size;

	count = (size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
	printf("Loading file '%s' to addr 0x%08x with size %d (0x%08x)...\n",
	       filename, addr, size, size);

	page.addr = (void *)addr;
	page.index = 0;
	page.inode = inode;
	for (i = 0; i < count; i++) {
		/*
		 * Make sure to not read beyond the requested size
		 */
		if (((i + 1) == count) && (size < inode->i_size))
			last_block_size = size - (i * PAGE_SIZE);

		err = do_readpage(c, inode, &page, last_block_size);
		if (err)
			break;

		page.addr += PAGE_SIZE;
		page.index++;
	}

	if (err)
		printf("Error reading file '%s'\n", filename);
	else {
	        sprintf(buf, "%X", size);
		setenv("filesize", buf);
		printf("Done\n");
	}

	ubifs_iput(inode);

out:
	ubi_close_volume(c->ubi);
	return err;
}
Commit	Line	Data
9eefe2a2 SR	1	/*
	2	* This file is part of UBIFS.
	3	*
	4	* Copyright (C) 2006-2008 Nokia Corporation.
	5	*
b1a14f8a	6	* (C) Copyright 2008-2010
9eefe2a2 SR	7	* Stefan Roese, DENX Software Engineering, [email protected].
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License version 2 as published by
	11	* the Free Software Foundation.
	12	*
	13	* This program is distributed in the hope that it will be useful, but WITHOUT
	14	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	15	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	16	* more details.
	17	*
	18	* You should have received a copy of the GNU General Public License along with
	19	* this program; if not, write to the Free Software Foundation, Inc., 51
	20	* Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	21	*
	22	* Authors: Artem Bityutskiy (Битюцкий Артём)
	23	* Adrian Hunter
	24	*/
	25
	26	#include "ubifs.h"
c1a0fd5f	27	#include <u-boot/zlib.h>
9eefe2a2	28
9eefe2a2 SR	29	DECLARE_GLOBAL_DATA_PTR;
	30
	31	/* compress.c */
	32
	33	/*
c1a0fd5f	34	* We need a wrapper for zunzip() because the parameters are
9eefe2a2 SR	35	* incompatible with the lzo decompressor.
	36	*/
	37	static int gzip_decompress(const unsigned char *in, size_t in_len,
	38	unsigned char out, size_t out_len)
	39	{
8044c138 VPP	40	return zunzip(out, out_len, (unsigned char )in,
8044c138 VPP	41	(unsigned long *)out_len, 0, 0);
9eefe2a2 SR	42	}
	43
	44	/* Fake description object for the "none" compressor */
	45	static struct ubifs_compressor none_compr = {
	46	.compr_type = UBIFS_COMPR_NONE,
	47	.name = "no compression",
	48	.capi_name = "",
	49	.decompress = NULL,
	50	};
	51
	52	static struct ubifs_compressor lzo_compr = {
	53	.compr_type = UBIFS_COMPR_LZO,
	54	.name = "LZO",
	55	.capi_name = "lzo",
	56	.decompress = lzo1x_decompress_safe,
	57	};
	58
	59	static struct ubifs_compressor zlib_compr = {
	60	.compr_type = UBIFS_COMPR_ZLIB,
	61	.name = "zlib",
	62	.capi_name = "deflate",
	63	.decompress = gzip_decompress,
	64	};
	65
	66	/* All UBIFS compressors */
	67	struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];
	68
	69	/**
	70	* ubifs_decompress - decompress data.
	71	* @in_buf: data to decompress
	72	* @in_len: length of the data to decompress
	73	* @out_buf: output buffer where decompressed data should
	74	* @out_len: output length is returned here
	75	* @compr_type: type of compression
	76	*
	77	* This function decompresses data from buffer @in_buf into buffer @out_buf.
	78	* The length of the uncompressed data is returned in @out_len. This functions
	79	* returns %0 on success or a negative error code on failure.
	80	*/
	81	int ubifs_decompress(const void in_buf, int in_len, void out_buf,
	82	int *out_len, int compr_type)
	83	{
	84	int err;
	85	struct ubifs_compressor *compr;
	86
	87	if (unlikely(compr_type < 0 \|\| compr_type >= UBIFS_COMPR_TYPES_CNT)) {
	88	ubifs_err("invalid compression type %d", compr_type);
	89	return -EINVAL;
	90	}
	91
	92	compr = ubifs_compressors[compr_type];
	93
	94	if (unlikely(!compr->capi_name)) {
	95	ubifs_err("%s compression is not compiled in", compr->name);
	96	return -EINVAL;
	97	}
	98
	99	if (compr_type == UBIFS_COMPR_NONE) {
	100	memcpy(out_buf, in_buf, in_len);
	101	*out_len = in_len;
	102	return 0;
	103	}
	104
	105	err = compr->decompress(in_buf, in_len, out_buf, (size_t *)out_len);
106	if (err)
107	ubifs_err("cannot decompress %d bytes, compressor %s, "
108	"error %d", in_len, compr->name, err);
109
110	return err;
111	}
112
113	/**
114	* compr_init - initialize a compressor.
115	* @compr: compressor description object
116	*
117	* This function initializes the requested compressor and returns zero in case
118	* of success or a negative error code in case of failure.
119	*/
120	static int __init compr_init(struct ubifs_compressor *compr)
121	{
122	ubifs_compressors[compr->compr_type] = compr;
521af04d	123
2e5167cc	124	#ifdef CONFIG_NEEDS_MANUAL_RELOC
9eefe2a2 SR	125	ubifs_compressors[compr->compr_type]->name += gd->reloc_off;
	126	ubifs_compressors[compr->compr_type]->capi_name += gd->reloc_off;
	127	ubifs_compressors[compr->compr_type]->decompress += gd->reloc_off;
521af04d PT	128	#endif
521af04d PT	129
9eefe2a2 SR	130	return 0;
	131	}
	132
	133	/**
	134	* ubifs_compressors_init - initialize UBIFS compressors.
	135	*
	136	* This function initializes the compressor which were compiled in. Returns
	137	* zero in case of success and a negative error code in case of failure.
	138	*/
	139	int __init ubifs_compressors_init(void)
	140	{
	141	int err;
	142
	143	err = compr_init(&lzo_compr);
	144	if (err)
	145	return err;
	146
	147	err = compr_init(&zlib_compr);
	148	if (err)
	149	return err;
	150
faac4fd8 ML	151	err = compr_init(&none_compr);
	152	if (err)
	153	return err;
	154
9eefe2a2 SR	155	return 0;
	156	}
	157
	158	/*
	159	* ubifsls...
	160	*/
	161
	162	static int filldir(struct ubifs_info c, const char name, int namlen,
	163	u64 ino, unsigned int d_type)
	164	{
	165	struct inode *inode;
	166	char filetime[32];
	167
	168	switch (d_type) {
	169	case UBIFS_ITYPE_REG:
	170	printf("\t");
	171	break;
	172	case UBIFS_ITYPE_DIR:
	173	printf("<DIR>\t");
	174	break;
	175	case UBIFS_ITYPE_LNK:
	176	printf("<LNK>\t");
	177	break;
	178	default:
	179	printf("other\t");
	180	break;
	181	}
	182
	183	inode = ubifs_iget(c->vfs_sb, ino);
	184	if (IS_ERR(inode)) {
	185	printf("%s: Error in ubifs_iget(), ino=%lld ret=%p!\n",
	186	__func__, ino, inode);
	187	return -1;
	188	}
	189	ctime_r((time_t *)&inode->i_mtime, filetime);
	190	printf("%9lld %24.24s ", inode->i_size, filetime);
	191	ubifs_iput(inode);
	192
	193	printf("%s\n", name);
	194
	195	return 0;
	196	}
	197
	198	static int ubifs_printdir(struct file file, void dirent)
	199	{
	200	int err, over = 0;
	201	struct qstr nm;
	202	union ubifs_key key;
	203	struct ubifs_dent_node *dent;
	204	struct inode *dir = file->f_path.dentry->d_inode;
	205	struct ubifs_info *c = dir->i_sb->s_fs_info;
	206
	207	dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
	208
	209	if (file->f_pos > UBIFS_S_KEY_HASH_MASK \|\| file->f_pos == 2)
	210	/*
	211	* The directory was seek'ed to a senseless position or there
	212	* are no more entries.
	213	*/
	214	return 0;
	215
	216	if (file->f_pos == 1) {
	217	/* Find the first entry in TNC and save it */
	218	lowest_dent_key(c, &key, dir->i_ino);
219	nm.name = NULL;
220	dent = ubifs_tnc_next_ent(c, &key, &nm);
221	if (IS_ERR(dent)) {
222	err = PTR_ERR(dent);
223	goto out;
224	}
225
226	file->f_pos = key_hash_flash(c, &dent->key);
227	file->private_data = dent;
228	}
229
230	dent = file->private_data;
231	if (!dent) {
232	/*
233	* The directory was seek'ed to and is now readdir'ed.
234	* Find the entry corresponding to @file->f_pos or the
235	* closest one.
236	*/
237	dent_key_init_hash(c, &key, dir->i_ino, file->f_pos);
238	nm.name = NULL;
239	dent = ubifs_tnc_next_ent(c, &key, &nm);
240	if (IS_ERR(dent)) {
241	err = PTR_ERR(dent);
242	goto out;
243	}
244	file->f_pos = key_hash_flash(c, &dent->key);
245	file->private_data = dent;
246	}
247
248	while (1) {
249	dbg_gen("feed '%s', ino %llu, new f_pos %#x",
250	dent->name, (unsigned long long)le64_to_cpu(dent->inum),
251	key_hash_flash(c, &dent->key));
252	ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);
253
254	nm.len = le16_to_cpu(dent->nlen);
255	over = filldir(c, (char *)dent->name, nm.len,
256	le64_to_cpu(dent->inum), dent->type);
257	if (over)
258	return 0;
259
260	/* Switch to the next entry */
261	key_read(c, &dent->key, &key);
262	nm.name = (char *)dent->name;
263	dent = ubifs_tnc_next_ent(c, &key, &nm);
264	if (IS_ERR(dent)) {
265	err = PTR_ERR(dent);
266	goto out;
267	}
268
269	kfree(file->private_data);
270	file->f_pos = key_hash_flash(c, &dent->key);
271	file->private_data = dent;
272	cond_resched();
273	}
274
275	out:
276	if (err != -ENOENT) {
277	ubifs_err("cannot find next direntry, error %d", err);
278	return err;
279	}
280
281	kfree(file->private_data);
282	file->private_data = NULL;
283	file->f_pos = 2;
284	return 0;
285	}
286
287	static int ubifs_finddir(struct super_block sb, char dirname,
288	unsigned long root_inum, unsigned long *inum)
289	{
290	int err;
291	struct qstr nm;
292	union ubifs_key key;
293	struct ubifs_dent_node *dent;
294	struct ubifs_info *c;
295	struct file *file;
296	struct dentry *dentry;
297	struct inode *dir;
be73913b	298	int ret = 0;
9eefe2a2 SR	299
	300	file = kzalloc(sizeof(struct file), 0);
	301	dentry = kzalloc(sizeof(struct dentry), 0);
	302	dir = kzalloc(sizeof(struct inode), 0);
	303	if (!file \|\| !dentry \|\| !dir) {
	304	printf("%s: Error, no memory for malloc!\n", __func__);
	305	err = -ENOMEM;
	306	goto out;
	307	}
	308
	309	dir->i_sb = sb;
	310	file->f_path.dentry = dentry;
	311	file->f_path.dentry->d_parent = dentry;
	312	file->f_path.dentry->d_inode = dir;
	313	file->f_path.dentry->d_inode->i_ino = root_inum;
	314	c = sb->s_fs_info;
	315
	316	dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
	317
	318	/* Find the first entry in TNC and save it */
	319	lowest_dent_key(c, &key, dir->i_ino);
	320	nm.name = NULL;
	321	dent = ubifs_tnc_next_ent(c, &key, &nm);
	322	if (IS_ERR(dent)) {
	323	err = PTR_ERR(dent);
	324	goto out;
	325	}
	326
	327	file->f_pos = key_hash_flash(c, &dent->key);
	328	file->private_data = dent;
	329
	330	while (1) {
	331	dbg_gen("feed '%s', ino %llu, new f_pos %#x",
	332	dent->name, (unsigned long long)le64_to_cpu(dent->inum),
	333	key_hash_flash(c, &dent->key));
	334	ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);
	335
	336	nm.len = le16_to_cpu(dent->nlen);
	337	if ((strncmp(dirname, (char *)dent->name, nm.len) == 0) &&
	338	(strlen(dirname) == nm.len)) {
	339	*inum = le64_to_cpu(dent->inum);
be73913b SR	340	ret = 1;
be73913b SR	341	goto out_free;
9eefe2a2 SR	342	}
	343
	344	/* Switch to the next entry */
	345	key_read(c, &dent->key, &key);
	346	nm.name = (char *)dent->name;
	347	dent = ubifs_tnc_next_ent(c, &key, &nm);
	348	if (IS_ERR(dent)) {
	349	err = PTR_ERR(dent);
	350	goto out;
	351	}
	352
	353	kfree(file->private_data);
	354	file->f_pos = key_hash_flash(c, &dent->key);
	355	file->private_data = dent;
	356	cond_resched();
	357	}
	358
	359	out:
be73913b	360	if (err != -ENOENT)
9eefe2a2	361	ubifs_err("cannot find next direntry, error %d", err);
9eefe2a2	362
be73913b	363	out_free:
3267bc1b WD	364	if (file->private_data)
3267bc1b WD	365	kfree(file->private_data);
9eefe2a2 SR	366	if (file)
	367	free(file);
	368	if (dentry)
	369	free(dentry);
	370	if (dir)
	371	free(dir);
	372
be73913b	373	return ret;
9eefe2a2 SR	374	}
	375
	376	static unsigned long ubifs_findfile(struct super_block sb, char filename)
	377	{
	378	int ret;
	379	char *next;
	380	char fpath[128];
9d7952e4	381	char symlinkpath[128];
9eefe2a2 SR	382	char *name = fpath;
	383	unsigned long root_inum = 1;
	384	unsigned long inum;
9d7952e4	385	int symlink_count = 0; /* Don't allow symlink recursion */
64b68178	386	char link_name[64];
9eefe2a2 SR	387
	388	strcpy(fpath, filename);
	389
	390	/* Remove all leading slashes */
	391	while (*name == '/')
	392	name++;
	393
	394	/*
	395	* Handle root-direcoty ('/')
	396	*/
	397	inum = root_inum;
	398	if (!name \|\| *name == '\0')
	399	return inum;
	400
	401	for (;;) {
9d7952e4 SK	402	struct inode *inode;
	403	struct ubifs_inode *ui;
	404
9eefe2a2 SR	405	/* Extract the actual part from the pathname. */
	406	next = strchr(name, '/');
	407	if (next) {
	408	/* Remove all leading slashes. */
	409	while (*next == '/')
	410	*(next++) = '\0';
	411	}
	412
	413	ret = ubifs_finddir(sb, name, root_inum, &inum);
9d7952e4 SK	414	if (!ret)
	415	return 0;
	416	inode = ubifs_iget(sb, inum);
	417
	418	if (!inode)
	419	return 0;
	420	ui = ubifs_inode(inode);
	421
	422	if ((inode->i_mode & S_IFMT) == S_IFLNK) {
9d7952e4 SK	423	char buf[128];
	424
	425	/* We have some sort of symlink recursion, bail out */
	426	if (symlink_count++ > 8) {
	427	printf("Symlink recursion, aborting\n");
	428	return 0;
	429	}
	430	memcpy(link_name, ui->data, ui->data_len);
	431	link_name[ui->data_len] = '\0';
	432
	433	if (link_name[0] == '/') {
	434	/* Absolute path, redo everything without
	435	* the leading slash */
	436	next = name = link_name + 1;
	437	root_inum = 1;
	438	continue;
	439	}
	440	/* Relative to cur dir */
ef37c683	441	sprintf(buf, "%s/%s",
9d7952e4 SK	442	link_name, next == NULL ? "" : next);
	443	memcpy(symlinkpath, buf, sizeof(buf));
	444	next = name = symlinkpath;
	445	continue;
	446	}
9eefe2a2 SR	447
	448	/*
	449	* Check if directory with this name exists
	450	*/
	451
	452	/* Found the node! */
9d7952e4 SK	453	if (!next \|\| *next == '\0')
9d7952e4 SK	454	return inum;
9eefe2a2 SR	455
	456	root_inum = inum;
	457	name = next;
	458	}
	459
	460	return 0;
	461	}
	462
	463	int ubifs_ls(char *filename)
	464	{
	465	struct ubifs_info *c = ubifs_sb->s_fs_info;
	466	struct file *file;
	467	struct dentry *dentry;
	468	struct inode *dir;
	469	void *dirent = NULL;
	470	unsigned long inum;
	471	int ret = 0;
	472
	473	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
	474	inum = ubifs_findfile(ubifs_sb, filename);
	475	if (!inum) {
	476	ret = -1;
	477	goto out;
	478	}
	479
	480	file = kzalloc(sizeof(struct file), 0);
	481	dentry = kzalloc(sizeof(struct dentry), 0);
	482	dir = kzalloc(sizeof(struct inode), 0);
	483	if (!file \|\| !dentry \|\| !dir) {
	484	printf("%s: Error, no memory for malloc!\n", __func__);
	485	ret = -ENOMEM;
	486	goto out_mem;
	487	}
	488
	489	dir->i_sb = ubifs_sb;
	490	file->f_path.dentry = dentry;
	491	file->f_path.dentry->d_parent = dentry;
	492	file->f_path.dentry->d_inode = dir;
	493	file->f_path.dentry->d_inode->i_ino = inum;
	494	file->f_pos = 1;
	495	file->private_data = NULL;
	496	ubifs_printdir(file, dirent);
	497
	498	out_mem:
	499	if (file)
	500	free(file);
	501	if (dentry)
	502	free(dentry);
	503	if (dir)
	504	free(dir);
	505
	506	out:
	507	ubi_close_volume(c->ubi);
	508	return ret;
	509	}
	510
	511	/*
	512	* ubifsload...
	513	*/
	514
	515	/* file.c */
	516
	517	static inline void kmap(struct page page)
	518	{
519	return page->addr;
520	}
521
522	static int read_block(struct inode inode, void addr, unsigned int block,
523	struct ubifs_data_node *dn)
524	{
525	struct ubifs_info *c = inode->i_sb->s_fs_info;
526	int err, len, out_len;
527	union ubifs_key key;
528	unsigned int dlen;
529
530	data_key_init(c, &key, inode->i_ino, block);
531	err = ubifs_tnc_lookup(c, &key, dn);
532	if (err) {
533	if (err == -ENOENT)
534	/* Not found, so it must be a hole */
535	memset(addr, 0, UBIFS_BLOCK_SIZE);
536	return err;
537	}
538
539	ubifs_assert(le64_to_cpu(dn->ch.sqnum) > ubifs_inode(inode)->creat_sqnum);
540
541	len = le32_to_cpu(dn->size);
542	if (len <= 0 \|\| len > UBIFS_BLOCK_SIZE)
543	goto dump;
544
545	dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
546	out_len = UBIFS_BLOCK_SIZE;
547	err = ubifs_decompress(&dn->data, dlen, addr, &out_len,
548	le16_to_cpu(dn->compr_type));
549	if (err \|\| len != out_len)
550	goto dump;
551
552	/*
553	* Data length can be less than a full block, even for blocks that are
554	* not the last in the file (e.g., as a result of making a hole and
555	* appending data). Ensure that the remainder is zeroed out.
556	*/
557	if (len < UBIFS_BLOCK_SIZE)
558	memset(addr + len, 0, UBIFS_BLOCK_SIZE - len);
559
560	return 0;
561
562	dump:
563	ubifs_err("bad data node (block %u, inode %lu)",
564	block, inode->i_ino);
565	dbg_dump_node(c, dn);
566	return -EINVAL;
567	}
568
b1a14f8a SR	569	static int do_readpage(struct ubifs_info c, struct inode inode,
b1a14f8a SR	570	struct page *page, int last_block_size)
9eefe2a2 SR	571	{
	572	void *addr;
	573	int err = 0, i;
	574	unsigned int block, beyond;
	575	struct ubifs_data_node *dn;
	576	loff_t i_size = inode->i_size;
	577
	578	dbg_gen("ino %lu, pg %lu, i_size %lld",
	579	inode->i_ino, page->index, i_size);
	580
	581	addr = kmap(page);
	582
	583	block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;
	584	beyond = (i_size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
	585	if (block >= beyond) {
	586	/* Reading beyond inode */
	587	memset(addr, 0, PAGE_CACHE_SIZE);
	588	goto out;
	589	}
	590
	591	dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS);
165f9859 DM	592	if (!dn)
165f9859 DM	593	return -ENOMEM;
9eefe2a2 SR	594
	595	i = 0;
	596	while (1) {
	597	int ret;
	598
	599	if (block >= beyond) {
	600	/* Reading beyond inode */
	601	err = -ENOENT;
	602	memset(addr, 0, UBIFS_BLOCK_SIZE);
	603	} else {
b1a14f8a SR	604	/*
	605	* Reading last block? Make sure to not write beyond
	606	* the requested size in the destination buffer.
	607	*/
	608	if (((block + 1) == beyond) \|\| last_block_size) {
	609	void *buff;
	610	int dlen;
	611
	612	/*
	613	* We need to buffer the data locally for the
	614	* last block. This is to not pad the
	615	* destination area to a multiple of
	616	* UBIFS_BLOCK_SIZE.
	617	*/
	618	buff = malloc(UBIFS_BLOCK_SIZE);
	619	if (!buff) {
	620	printf("%s: Error, malloc fails!\n",
	621	__func__);
	622	err = -ENOMEM;
9eefe2a2	623	break;
b1a14f8a SR	624	}
	625
	626	/* Read block-size into temp buffer */
	627	ret = read_block(inode, buff, block, dn);
	628	if (ret) {
	629	err = ret;
	630	if (err != -ENOENT) {
	631	free(buff);
	632	break;
	633	}
	634	}
	635
	636	if (last_block_size)
	637	dlen = last_block_size;
	638	else
	639	dlen = le32_to_cpu(dn->size);
	640
	641	/* Now copy required size back to dest */
	642	memcpy(addr, buff, dlen);
	643
	644	free(buff);
	645	} else {
	646	ret = read_block(inode, addr, block, dn);
	647	if (ret) {
	648	err = ret;
	649	if (err != -ENOENT)
	650	break;
	651	}
9eefe2a2 SR	652	}
	653	}
	654	if (++i >= UBIFS_BLOCKS_PER_PAGE)
	655	break;
	656	block += 1;
	657	addr += UBIFS_BLOCK_SIZE;
	658	}
	659	if (err) {
	660	if (err == -ENOENT) {
	661	/* Not found, so it must be a hole */
	662	dbg_gen("hole");
	663	goto out_free;
	664	}
	665	ubifs_err("cannot read page %lu of inode %lu, error %d",
	666	page->index, inode->i_ino, err);
	667	goto error;
	668	}
	669
	670	out_free:
	671	kfree(dn);
	672	out:
	673	return 0;
	674
	675	error:
	676	kfree(dn);
	677	return err;
	678	}
	679
	680	int ubifs_load(char *filename, u32 addr, u32 size)
	681	{
	682	struct ubifs_info *c = ubifs_sb->s_fs_info;
	683	unsigned long inum;
	684	struct inode *inode;
	685	struct page page;
	686	int err = 0;
	687	int i;
	688	int count;
b1a14f8a	689	int last_block_size = 0;
46d7274c	690	char buf [10];
9eefe2a2 SR	691
9eefe2a2 SR	692	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
9d7952e4 SK	693	/* ubifs_findfile will resolve symlinks, so we know that we get
9d7952e4 SK	694	* the real file here */
9eefe2a2 SR	695	inum = ubifs_findfile(ubifs_sb, filename);
	696	if (!inum) {
	697	err = -1;
	698	goto out;
	699	}
	700
	701	/*
	702	* Read file inode
	703	*/
	704	inode = ubifs_iget(ubifs_sb, inum);
	705	if (IS_ERR(inode)) {
	706	printf("%s: Error reading inode %ld!\n", __func__, inum);
	707	err = PTR_ERR(inode);
	708	goto out;
	709	}
	710
9eefe2a2 SR	711	/*
	712	* If no size was specified or if size bigger than filesize
	713	* set size to filesize
	714	*/
	715	if ((size == 0) \|\| (size > inode->i_size))
	716	size = inode->i_size;
	717
	718	count = (size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
	719	printf("Loading file '%s' to addr 0x%08x with size %d (0x%08x)...\n",
	720	filename, addr, size, size);
	721
	722	page.addr = (void *)addr;
	723	page.index = 0;
	724	page.inode = inode;
	725	for (i = 0; i < count; i++) {
b1a14f8a SR	726	/*
	727	* Make sure to not read beyond the requested size
	728	*/
	729	if (((i + 1) == count) && (size < inode->i_size))
	730	last_block_size = size - (i * PAGE_SIZE);
	731
	732	err = do_readpage(c, inode, &page, last_block_size);
9eefe2a2 SR	733	if (err)
	734	break;
	735
	736	page.addr += PAGE_SIZE;
	737	page.index++;
	738	}
	739
	740	if (err)
	741	printf("Error reading file '%s'\n", filename);
46d7274c	742	else {
aaf6935b	743	sprintf(buf, "%X", size);
46d7274c	744	setenv("filesize", buf);
9eefe2a2	745	printf("Done\n");
46d7274c	746	}
9eefe2a2 SR	747
	748	ubifs_iput(inode);
	749
	750	out:
	751	ubi_close_volume(c->ubi);
	752	return err;
	753	}