[linux-2.6-block.git] / fs / romfs / storage.c

/* RomFS storage access routines
 *
 * Copyright © 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * 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 of the License, or (at your option) any later version.
 */

#include <linux/fs.h>
#include <linux/mtd/super.h>
#include <linux/buffer_head.h>
#include "internal.h"

#if !defined(CONFIG_ROMFS_ON_MTD) && !defined(CONFIG_ROMFS_ON_BLOCK)
#error no ROMFS backing store interface configured
#endif

#ifdef CONFIG_ROMFS_ON_MTD
#define ROMFS_MTD_READ(sb, ...) ((sb)->s_mtd->read((sb)->s_mtd, ##__VA_ARGS__))

/*
 * read data from an romfs image on an MTD device
 */
static int romfs_mtd_read(struct super_block *sb, unsigned long pos,
			  void *buf, size_t buflen)
{
	size_t rlen;
	int ret;

	ret = ROMFS_MTD_READ(sb, pos, buflen, &rlen, buf);
	return (ret < 0 || rlen != buflen) ? -EIO : 0;
}

/*
 * determine the length of a string in a romfs image on an MTD device
 */
static ssize_t romfs_mtd_strnlen(struct super_block *sb,
				 unsigned long pos, size_t maxlen)
{
	ssize_t n = 0;
	size_t segment;
	u_char buf[16], *p;
	size_t len;
	int ret;

	/* scan the string up to 16 bytes at a time */
	while (maxlen > 0) {
		segment = min_t(size_t, maxlen, 16);
		ret = ROMFS_MTD_READ(sb, pos, segment, &len, buf);
		if (ret < 0)
			return ret;
		p = memchr(buf, 0, len);
		if (p)
			return n + (p - buf);
		maxlen -= len;
		pos += len;
		n += len;
	}

	return n;
}

/*
 * compare a string to one in a romfs image on MTD
 * - return 1 if matched, 0 if differ, -ve if error
 */
static int romfs_mtd_strcmp(struct super_block *sb, unsigned long pos,
			    const char *str, size_t size)
{
	u_char buf[17];
	size_t len, segment;
	int ret;

	/* scan the string up to 16 bytes at a time, and attempt to grab the
	 * trailing NUL whilst we're at it */
	buf[0] = 0xff;

	while (size > 0) {
		segment = min_t(size_t, size + 1, 17);
		ret = ROMFS_MTD_READ(sb, pos, segment, &len, buf);
		if (ret < 0)
			return ret;
		len--;
		if (memcmp(buf, str, len) != 0)
			return 0;
		buf[0] = buf[len];
		size -= len;
		pos += len;
		str += len;
	}

	/* check the trailing NUL was */
	if (buf[0])
		return 0;

	return 1;
}
#endif /* CONFIG_ROMFS_ON_MTD */

#ifdef CONFIG_ROMFS_ON_BLOCK
/*
 * read data from an romfs image on a block device
 */
static int romfs_blk_read(struct super_block *sb, unsigned long pos,
			  void *buf, size_t buflen)
{
	struct buffer_head *bh;
	unsigned long offset;
	size_t segment;

	/* copy the string up to blocksize bytes at a time */
	while (buflen > 0) {
		offset = pos & (ROMBSIZE - 1);
		segment = min_t(size_t, buflen, ROMBSIZE - offset);
		bh = sb_bread(sb, pos >> ROMBSBITS);
		if (!bh)
			return -EIO;
		memcpy(buf, bh->b_data + offset, segment);
		brelse(bh);
		buflen -= segment;
		pos += segment;
	}

	return 0;
}

/*
 * determine the length of a string in romfs on a block device
 */
static ssize_t romfs_blk_strnlen(struct super_block *sb,
				 unsigned long pos, size_t limit)
{
	struct buffer_head *bh;
	unsigned long offset;
	ssize_t n = 0;
	size_t segment;
	u_char *buf, *p;

	/* scan the string up to blocksize bytes at a time */
	while (limit > 0) {
		offset = pos & (ROMBSIZE - 1);
		segment = min_t(size_t, limit, ROMBSIZE - offset);
		bh = sb_bread(sb, pos >> ROMBSBITS);
		if (!bh)
			return -EIO;
		buf = bh->b_data + offset;
		p = memchr(buf, 0, segment);
		brelse(bh);
		if (p)
			return n + (p - buf);
		limit -= segment;
		pos += segment;
		n += segment;
	}

	return n;
}

/*
 * compare a string to one in a romfs image on a block device
 * - return 1 if matched, 0 if differ, -ve if error
 */
static int romfs_blk_strcmp(struct super_block *sb, unsigned long pos,
			    const char *str, size_t size)
{
	struct buffer_head *bh;
	unsigned long offset;
	size_t segment;
	bool matched, terminated = false;

	/* compare string up to a block at a time */
	while (size > 0) {
		offset = pos & (ROMBSIZE - 1);
		segment = min_t(size_t, size, ROMBSIZE - offset);
		bh = sb_bread(sb, pos >> ROMBSBITS);
		if (!bh)
			return -EIO;
		matched = (memcmp(bh->b_data + offset, str, segment) == 0);

		size -= segment;
		pos += segment;
		str += segment;
		if (matched && size == 0 && offset + segment < ROMBSIZE) {
			if (!bh->b_data[offset + segment])
				terminated = true;
			else
				matched = false;
		}
		brelse(bh);
		if (!matched)
			return 0;
	}

	if (!terminated) {
		/* the terminating NUL must be on the first byte of the next
		 * block */
		BUG_ON((pos & (ROMBSIZE - 1)) != 0);
		bh = sb_bread(sb, pos >> ROMBSBITS);
		if (!bh)
			return -EIO;
		matched = !bh->b_data[0];
		brelse(bh);
		if (!matched)
			return 0;
	}

	return 1;
}
#endif /* CONFIG_ROMFS_ON_BLOCK */

/*
 * read data from the romfs image
 */
int romfs_dev_read(struct super_block *sb, unsigned long pos,
		   void *buf, size_t buflen)
{
	size_t limit;

	limit = romfs_maxsize(sb);
	if (pos >= limit)
		return -EIO;
	if (buflen > limit - pos)
		buflen = limit - pos;

#ifdef CONFIG_ROMFS_ON_MTD
	if (sb->s_mtd)
		return romfs_mtd_read(sb, pos, buf, buflen);
#endif
#ifdef CONFIG_ROMFS_ON_BLOCK
	if (sb->s_bdev)
		return romfs_blk_read(sb, pos, buf, buflen);
#endif
	return -EIO;
}

/*
 * determine the length of a string in romfs
 */
ssize_t romfs_dev_strnlen(struct super_block *sb,
			  unsigned long pos, size_t maxlen)
{
	size_t limit;

	limit = romfs_maxsize(sb);
	if (pos >= limit)
		return -EIO;
	if (maxlen > limit - pos)
		maxlen = limit - pos;

#ifdef CONFIG_ROMFS_ON_MTD
	if (sb->s_mtd)
		return romfs_mtd_strnlen(sb, pos, limit);
#endif
#ifdef CONFIG_ROMFS_ON_BLOCK
	if (sb->s_bdev)
		return romfs_blk_strnlen(sb, pos, limit);
#endif
	return -EIO;
}

/*
 * compare a string to one in romfs
 * - the string to be compared to, str, may not be NUL-terminated; instead the
 *   string is of the specified size
 * - return 1 if matched, 0 if differ, -ve if error
 */
int romfs_dev_strcmp(struct super_block *sb, unsigned long pos,
		     const char *str, size_t size)
{
	size_t limit;

	limit = romfs_maxsize(sb);
	if (pos >= limit)
		return -EIO;
	if (size > ROMFS_MAXFN)
		return -ENAMETOOLONG;
	if (size + 1 > limit - pos)
		return -EIO;

#ifdef CONFIG_ROMFS_ON_MTD
	if (sb->s_mtd)
		return romfs_mtd_strcmp(sb, pos, str, size);
#endif
#ifdef CONFIG_ROMFS_ON_BLOCK
	if (sb->s_bdev)
		return romfs_blk_strcmp(sb, pos, str, size);
#endif
	return -EIO;
}
Commit	Line	Data
da4458bd DH	1	/* RomFS storage access routines
	2	*
	3	* Copyright © 2007 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/fs.h>
	13	#include <linux/mtd/super.h>
	14	#include <linux/buffer_head.h>
	15	#include "internal.h"
	16
	17	#if !defined(CONFIG_ROMFS_ON_MTD) && !defined(CONFIG_ROMFS_ON_BLOCK)
	18	#error no ROMFS backing store interface configured
	19	#endif
	20
	21	#ifdef CONFIG_ROMFS_ON_MTD
	22	#define ROMFS_MTD_READ(sb, ...) ((sb)->s_mtd->read((sb)->s_mtd, ##__VA_ARGS__))
	23
	24	/*
	25	* read data from an romfs image on an MTD device
	26	*/
	27	static int romfs_mtd_read(struct super_block *sb, unsigned long pos,
	28	void *buf, size_t buflen)
	29	{
	30	size_t rlen;
	31	int ret;
	32
	33	ret = ROMFS_MTD_READ(sb, pos, buflen, &rlen, buf);
	34	return (ret < 0 \|\| rlen != buflen) ? -EIO : 0;
	35	}
	36
	37	/*
	38	* determine the length of a string in a romfs image on an MTD device
	39	*/
	40	static ssize_t romfs_mtd_strnlen(struct super_block *sb,
	41	unsigned long pos, size_t maxlen)
	42	{
	43	ssize_t n = 0;
	44	size_t segment;
	45	u_char buf[16], *p;
	46	size_t len;
	47	int ret;
	48
	49	/* scan the string up to 16 bytes at a time */
	50	while (maxlen > 0) {
	51	segment = min_t(size_t, maxlen, 16);
	52	ret = ROMFS_MTD_READ(sb, pos, segment, &len, buf);
	53	if (ret < 0)
	54	return ret;
	55	p = memchr(buf, 0, len);
	56	if (p)
	57	return n + (p - buf);
	58	maxlen -= len;
	59	pos += len;
	60	n += len;
	61	}
	62
	63	return n;
	64	}
65
66	/*
67	* compare a string to one in a romfs image on MTD
68	* - return 1 if matched, 0 if differ, -ve if error
69	*/
84baf74b DH	70	static int romfs_mtd_strcmp(struct super_block *sb, unsigned long pos,
84baf74b DH	71	const char *str, size_t size)
da4458bd	72	{
84baf74b	73	u_char buf[17];
da4458bd DH	74	size_t len, segment;
	75	int ret;
	76
84baf74b DH	77	/* scan the string up to 16 bytes at a time, and attempt to grab the
	78	* trailing NUL whilst we're at it */
	79	buf[0] = 0xff;
	80
da4458bd	81	while (size > 0) {
84baf74b	82	segment = min_t(size_t, size + 1, 17);
da4458bd DH	83	ret = ROMFS_MTD_READ(sb, pos, segment, &len, buf);
	84	if (ret < 0)
	85	return ret;
84baf74b	86	len--;
da4458bd DH	87	if (memcmp(buf, str, len) != 0)
da4458bd DH	88	return 0;
84baf74b	89	buf[0] = buf[len];
da4458bd DH	90	size -= len;
	91	pos += len;
	92	str += len;
	93	}
	94
84baf74b DH	95	/* check the trailing NUL was */
	96	if (buf[0])
	97	return 0;
	98
da4458bd DH	99	return 1;
	100	}
	101	#endif /* CONFIG_ROMFS_ON_MTD */
	102
	103	#ifdef CONFIG_ROMFS_ON_BLOCK
	104	/*
	105	* read data from an romfs image on a block device
	106	*/
	107	static int romfs_blk_read(struct super_block *sb, unsigned long pos,
	108	void *buf, size_t buflen)
	109	{
	110	struct buffer_head *bh;
	111	unsigned long offset;
	112	size_t segment;
	113
	114	/* copy the string up to blocksize bytes at a time */
	115	while (buflen > 0) {
	116	offset = pos & (ROMBSIZE - 1);
	117	segment = min_t(size_t, buflen, ROMBSIZE - offset);
	118	bh = sb_bread(sb, pos >> ROMBSBITS);
	119	if (!bh)
	120	return -EIO;
	121	memcpy(buf, bh->b_data + offset, segment);
	122	brelse(bh);
	123	buflen -= segment;
	124	pos += segment;
	125	}
	126
	127	return 0;
	128	}
	129
	130	/*
	131	* determine the length of a string in romfs on a block device
	132	*/
	133	static ssize_t romfs_blk_strnlen(struct super_block *sb,
	134	unsigned long pos, size_t limit)
	135	{
	136	struct buffer_head *bh;
	137	unsigned long offset;
	138	ssize_t n = 0;
	139	size_t segment;
	140	u_char buf, p;
	141
	142	/* scan the string up to blocksize bytes at a time */
	143	while (limit > 0) {
	144	offset = pos & (ROMBSIZE - 1);
	145	segment = min_t(size_t, limit, ROMBSIZE - offset);
	146	bh = sb_bread(sb, pos >> ROMBSBITS);
	147	if (!bh)
	148	return -EIO;
	149	buf = bh->b_data + offset;
	150	p = memchr(buf, 0, segment);
	151	brelse(bh);
	152	if (p)
	153	return n + (p - buf);
	154	limit -= segment;
	155	pos += segment;
	156	n += segment;
	157	}
	158
	159	return n;
	160	}
	161
	162	/*
163	* compare a string to one in a romfs image on a block device
164	* - return 1 if matched, 0 if differ, -ve if error
165	*/
84baf74b DH	166	static int romfs_blk_strcmp(struct super_block *sb, unsigned long pos,
84baf74b DH	167	const char *str, size_t size)
da4458bd DH	168	{
	169	struct buffer_head *bh;
	170	unsigned long offset;
	171	size_t segment;
84baf74b	172	bool matched, terminated = false;
da4458bd	173
84baf74b	174	/* compare string up to a block at a time */
da4458bd DH	175	while (size > 0) {
	176	offset = pos & (ROMBSIZE - 1);
	177	segment = min_t(size_t, size, ROMBSIZE - offset);
	178	bh = sb_bread(sb, pos >> ROMBSBITS);
	179	if (!bh)
	180	return -EIO;
84baf74b DH	181	matched = (memcmp(bh->b_data + offset, str, segment) == 0);
84baf74b DH	182
da4458bd DH	183	size -= segment;
	184	pos += segment;
	185	str += segment;
84baf74b DH	186	if (matched && size == 0 && offset + segment < ROMBSIZE) {
	187	if (!bh->b_data[offset + segment])
	188	terminated = true;
	189	else
	190	matched = false;
	191	}
	192	brelse(bh);
	193	if (!matched)
	194	return 0;
	195	}
	196
	197	if (!terminated) {
	198	/* the terminating NUL must be on the first byte of the next
	199	* block */
	200	BUG_ON((pos & (ROMBSIZE - 1)) != 0);
	201	bh = sb_bread(sb, pos >> ROMBSBITS);
	202	if (!bh)
	203	return -EIO;
	204	matched = !bh->b_data[0];
	205	brelse(bh);
	206	if (!matched)
	207	return 0;
da4458bd DH	208	}
	209
	210	return 1;
	211	}
	212	#endif /* CONFIG_ROMFS_ON_BLOCK */
	213
	214	/*
	215	* read data from the romfs image
	216	*/
	217	int romfs_dev_read(struct super_block *sb, unsigned long pos,
	218	void *buf, size_t buflen)
	219	{
	220	size_t limit;
	221
	222	limit = romfs_maxsize(sb);
	223	if (pos >= limit)
	224	return -EIO;
	225	if (buflen > limit - pos)
	226	buflen = limit - pos;
	227
	228	#ifdef CONFIG_ROMFS_ON_MTD
	229	if (sb->s_mtd)
	230	return romfs_mtd_read(sb, pos, buf, buflen);
	231	#endif
	232	#ifdef CONFIG_ROMFS_ON_BLOCK
	233	if (sb->s_bdev)
	234	return romfs_blk_read(sb, pos, buf, buflen);
	235	#endif
	236	return -EIO;
	237	}
	238
	239	/*
	240	* determine the length of a string in romfs
	241	*/
	242	ssize_t romfs_dev_strnlen(struct super_block *sb,
	243	unsigned long pos, size_t maxlen)
	244	{
	245	size_t limit;
	246
	247	limit = romfs_maxsize(sb);
	248	if (pos >= limit)
	249	return -EIO;
	250	if (maxlen > limit - pos)
	251	maxlen = limit - pos;
	252
	253	#ifdef CONFIG_ROMFS_ON_MTD
	254	if (sb->s_mtd)
	255	return romfs_mtd_strnlen(sb, pos, limit);
	256	#endif
	257	#ifdef CONFIG_ROMFS_ON_BLOCK
	258	if (sb->s_bdev)
	259	return romfs_blk_strnlen(sb, pos, limit);
	260	#endif
	261	return -EIO;
	262	}
	263
	264	/*
	265	* compare a string to one in romfs
84baf74b DH	266	* - the string to be compared to, str, may not be NUL-terminated; instead the
84baf74b DH	267	* string is of the specified size
da4458bd DH	268	* - return 1 if matched, 0 if differ, -ve if error
da4458bd DH	269	*/
84baf74b DH	270	int romfs_dev_strcmp(struct super_block *sb, unsigned long pos,
84baf74b DH	271	const char *str, size_t size)
da4458bd DH	272	{
	273	size_t limit;
	274
	275	limit = romfs_maxsize(sb);
	276	if (pos >= limit)
	277	return -EIO;
	278	if (size > ROMFS_MAXFN)
	279	return -ENAMETOOLONG;
84baf74b	280	if (size + 1 > limit - pos)
da4458bd DH	281	return -EIO;
	282
	283	#ifdef CONFIG_ROMFS_ON_MTD
	284	if (sb->s_mtd)
84baf74b	285	return romfs_mtd_strcmp(sb, pos, str, size);
da4458bd DH	286	#endif
	287	#ifdef CONFIG_ROMFS_ON_BLOCK
	288	if (sb->s_bdev)
84baf74b	289	return romfs_blk_strcmp(sb, pos, str, size);
da4458bd DH	290	#endif
	291	return -EIO;
	292	}