[net-next-2.6.git] / fs / logfs / dev_mtd.c

/*
 * fs/logfs/dev_mtd.c	- Device access methods for MTD
 *
 * As should be obvious for Linux kernel code, license is GPLv2
 *
 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
 */
#include "logfs.h"
#include <linux/completion.h>
#include <linux/mount.h>
#include <linux/sched.h>
#include <linux/slab.h>

#define PAGE_OFS(ofs) ((ofs) & (PAGE_SIZE-1))

static int mtd_read(struct super_block *sb, loff_t ofs, size_t len, void *buf)
{
	struct mtd_info *mtd = logfs_super(sb)->s_mtd;
	size_t retlen;
	int ret;

	ret = mtd->read(mtd, ofs, len, &retlen, buf);
	BUG_ON(ret == -EINVAL);
	if (ret)
		return ret;

	/* Not sure if we should loop instead. */
	if (retlen != len)
		return -EIO;

	return 0;
}

static int mtd_write(struct super_block *sb, loff_t ofs, size_t len, void *buf)
{
	struct logfs_super *super = logfs_super(sb);
	struct mtd_info *mtd = super->s_mtd;
	size_t retlen;
	loff_t page_start, page_end;
	int ret;

	if (super->s_flags & LOGFS_SB_FLAG_RO)
		return -EROFS;

	BUG_ON((ofs >= mtd->size) || (len > mtd->size - ofs));
	BUG_ON(ofs != (ofs >> super->s_writeshift) << super->s_writeshift);
	BUG_ON(len > PAGE_CACHE_SIZE);
	page_start = ofs & PAGE_CACHE_MASK;
	page_end = PAGE_CACHE_ALIGN(ofs + len) - 1;
	ret = mtd->write(mtd, ofs, len, &retlen, buf);
	if (ret || (retlen != len))
		return -EIO;

	return 0;
}

/*
 * For as long as I can remember (since about 2001) mtd->erase has been an
 * asynchronous interface lacking the first driver to actually use the
 * asynchronous properties.  So just to prevent the first implementor of such
 * a thing from breaking logfs in 2350, we do the usual pointless dance to
 * declare a completion variable and wait for completion before returning
 * from mtd_erase().  What an excercise in futility!
 */
static void logfs_erase_callback(struct erase_info *ei)
{
	complete((struct completion *)ei->priv);
}

static int mtd_erase_mapping(struct super_block *sb, loff_t ofs, size_t len)
{
	struct logfs_super *super = logfs_super(sb);
	struct address_space *mapping = super->s_mapping_inode->i_mapping;
	struct page *page;
	pgoff_t index = ofs >> PAGE_SHIFT;

	for (index = ofs >> PAGE_SHIFT; index < (ofs + len) >> PAGE_SHIFT; index++) {
		page = find_get_page(mapping, index);
		if (!page)
			continue;
		memset(page_address(page), 0xFF, PAGE_SIZE);
		page_cache_release(page);
	}
	return 0;
}

static int mtd_erase(struct super_block *sb, loff_t ofs, size_t len,
		int ensure_write)
{
	struct mtd_info *mtd = logfs_super(sb)->s_mtd;
	struct erase_info ei;
	DECLARE_COMPLETION_ONSTACK(complete);
	int ret;

	BUG_ON(len % mtd->erasesize);
	if (logfs_super(sb)->s_flags & LOGFS_SB_FLAG_RO)
		return -EROFS;

	memset(&ei, 0, sizeof(ei));
	ei.mtd = mtd;
	ei.addr = ofs;
	ei.len = len;
	ei.callback = logfs_erase_callback;
	ei.priv = (long)&complete;
	ret = mtd->erase(mtd, &ei);
	if (ret)
		return -EIO;

	wait_for_completion(&complete);
	if (ei.state != MTD_ERASE_DONE)
		return -EIO;
	return mtd_erase_mapping(sb, ofs, len);
}

static void mtd_sync(struct super_block *sb)
{
	struct mtd_info *mtd = logfs_super(sb)->s_mtd;

	if (mtd->sync)
		mtd->sync(mtd);
}

static int mtd_readpage(void *_sb, struct page *page)
{
	struct super_block *sb = _sb;
	int err;

	err = mtd_read(sb, page->index << PAGE_SHIFT, PAGE_SIZE,
			page_address(page));
	if (err == -EUCLEAN || err == -EBADMSG) {
		/* -EBADMSG happens regularly on power failures */
		err = 0;
		/* FIXME: force GC this segment */
	}
	if (err) {
		ClearPageUptodate(page);
		SetPageError(page);
	} else {
		SetPageUptodate(page);
		ClearPageError(page);
	}
	unlock_page(page);
	return err;
}

static struct page *mtd_find_first_sb(struct super_block *sb, u64 *ofs)
{
	struct logfs_super *super = logfs_super(sb);
	struct address_space *mapping = super->s_mapping_inode->i_mapping;
	filler_t *filler = mtd_readpage;
	struct mtd_info *mtd = super->s_mtd;

	if (!mtd->block_isbad)
		return NULL;

	*ofs = 0;
	while (mtd->block_isbad(mtd, *ofs)) {
		*ofs += mtd->erasesize;
		if (*ofs >= mtd->size)
			return NULL;
	}
	BUG_ON(*ofs & ~PAGE_MASK);
	return read_cache_page(mapping, *ofs >> PAGE_SHIFT, filler, sb);
}

static struct page *mtd_find_last_sb(struct super_block *sb, u64 *ofs)
{
	struct logfs_super *super = logfs_super(sb);
	struct address_space *mapping = super->s_mapping_inode->i_mapping;
	filler_t *filler = mtd_readpage;
	struct mtd_info *mtd = super->s_mtd;

	if (!mtd->block_isbad)
		return NULL;

	*ofs = mtd->size - mtd->erasesize;
	while (mtd->block_isbad(mtd, *ofs)) {
		*ofs -= mtd->erasesize;
		if (*ofs <= 0)
			return NULL;
	}
	*ofs = *ofs + mtd->erasesize - 0x1000;
	BUG_ON(*ofs & ~PAGE_MASK);
	return read_cache_page(mapping, *ofs >> PAGE_SHIFT, filler, sb);
}

static int __mtd_writeseg(struct super_block *sb, u64 ofs, pgoff_t index,
		size_t nr_pages)
{
	struct logfs_super *super = logfs_super(sb);
	struct address_space *mapping = super->s_mapping_inode->i_mapping;
	struct page *page;
	int i, err;

	for (i = 0; i < nr_pages; i++) {
		page = find_lock_page(mapping, index + i);
		BUG_ON(!page);

		err = mtd_write(sb, page->index << PAGE_SHIFT, PAGE_SIZE,
				page_address(page));
		unlock_page(page);
		page_cache_release(page);
		if (err)
			return err;
	}
	return 0;
}

static void mtd_writeseg(struct super_block *sb, u64 ofs, size_t len)
{
	struct logfs_super *super = logfs_super(sb);
	int head;

	if (super->s_flags & LOGFS_SB_FLAG_RO)
		return;

	if (len == 0) {
		/* This can happen when the object fit perfectly into a
		 * segment, the segment gets written per sync and subsequently
		 * closed.
		 */
		return;
	}
	head = ofs & (PAGE_SIZE - 1);
	if (head) {
		ofs -= head;
		len += head;
	}
	len = PAGE_ALIGN(len);
	__mtd_writeseg(sb, ofs, ofs >> PAGE_SHIFT, len >> PAGE_SHIFT);
}

static void mtd_put_device(struct logfs_super *s)
{
	put_mtd_device(s->s_mtd);
}

static int mtd_can_write_buf(struct super_block *sb, u64 ofs)
{
	struct logfs_super *super = logfs_super(sb);
	void *buf;
	int err;

	buf = kmalloc(super->s_writesize, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;
	err = mtd_read(sb, ofs, super->s_writesize, buf);
	if (err)
		goto out;
	if (memchr_inv(buf, 0xff, super->s_writesize))
		err = -EIO;
	kfree(buf);
out:
	return err;
}

static const struct logfs_device_ops mtd_devops = {
	.find_first_sb	= mtd_find_first_sb,
	.find_last_sb	= mtd_find_last_sb,
	.readpage	= mtd_readpage,
	.writeseg	= mtd_writeseg,
	.erase		= mtd_erase,
	.can_write_buf	= mtd_can_write_buf,
	.sync		= mtd_sync,
	.put_device	= mtd_put_device,
};

int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr)
{
	struct mtd_info *mtd = get_mtd_device(NULL, mtdnr);
	if (IS_ERR(mtd))
		return PTR_ERR(mtd);

	s->s_bdev = NULL;
	s->s_mtd = mtd;
	s->s_devops = &mtd_devops;
	return 0;
}
Commit	Line	Data
5db53f3e JE	1	/*
	2	* fs/logfs/dev_mtd.c - Device access methods for MTD
	3	*
	4	* As should be obvious for Linux kernel code, license is GPLv2
	5	*
	6	* Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
	7	*/
	8	#include "logfs.h"
	9	#include <linux/completion.h>
	10	#include <linux/mount.h>
	11	#include <linux/sched.h>
6f485b41	12	#include <linux/slab.h>
5db53f3e JE	13
	14	#define PAGE_OFS(ofs) ((ofs) & (PAGE_SIZE-1))
	15
	16	static int mtd_read(struct super_block sb, loff_t ofs, size_t len, void buf)
	17	{
	18	struct mtd_info *mtd = logfs_super(sb)->s_mtd;
	19	size_t retlen;
	20	int ret;
	21
	22	ret = mtd->read(mtd, ofs, len, &retlen, buf);
	23	BUG_ON(ret == -EINVAL);
	24	if (ret)
	25	return ret;
	26
	27	/* Not sure if we should loop instead. */
	28	if (retlen != len)
	29	return -EIO;
	30
	31	return 0;
	32	}
	33
	34	static int mtd_write(struct super_block sb, loff_t ofs, size_t len, void buf)
	35	{
	36	struct logfs_super *super = logfs_super(sb);
	37	struct mtd_info *mtd = super->s_mtd;
	38	size_t retlen;
	39	loff_t page_start, page_end;
	40	int ret;
	41
	42	if (super->s_flags & LOGFS_SB_FLAG_RO)
	43	return -EROFS;
	44
	45	BUG_ON((ofs >= mtd->size) \|\| (len > mtd->size - ofs));
	46	BUG_ON(ofs != (ofs >> super->s_writeshift) << super->s_writeshift);
	47	BUG_ON(len > PAGE_CACHE_SIZE);
	48	page_start = ofs & PAGE_CACHE_MASK;
	49	page_end = PAGE_CACHE_ALIGN(ofs + len) - 1;
	50	ret = mtd->write(mtd, ofs, len, &retlen, buf);
	51	if (ret \|\| (retlen != len))
	52	return -EIO;
	53
	54	return 0;
	55	}
	56
	57	/*
	58	* For as long as I can remember (since about 2001) mtd->erase has been an
	59	* asynchronous interface lacking the first driver to actually use the
	60	* asynchronous properties. So just to prevent the first implementor of such
	61	* a thing from breaking logfs in 2350, we do the usual pointless dance to
	62	* declare a completion variable and wait for completion before returning
	63	* from mtd_erase(). What an excercise in futility!
	64	*/
	65	static void logfs_erase_callback(struct erase_info *ei)
	66	{
	67	complete((struct completion *)ei->priv);
	68	}
	69
	70	static int mtd_erase_mapping(struct super_block *sb, loff_t ofs, size_t len)
	71	{
	72	struct logfs_super *super = logfs_super(sb);
	73	struct address_space *mapping = super->s_mapping_inode->i_mapping;
	74	struct page *page;
	75	pgoff_t index = ofs >> PAGE_SHIFT;
	76
77	for (index = ofs >> PAGE_SHIFT; index < (ofs + len) >> PAGE_SHIFT; index++) {
78	page = find_get_page(mapping, index);
79	if (!page)
80	continue;
81	memset(page_address(page), 0xFF, PAGE_SIZE);
82	page_cache_release(page);
83	}
84	return 0;
85	}
86
9421502b JE	87	static int mtd_erase(struct super_block *sb, loff_t ofs, size_t len,
9421502b JE	88	int ensure_write)
5db53f3e JE	89	{
	90	struct mtd_info *mtd = logfs_super(sb)->s_mtd;
	91	struct erase_info ei;
	92	DECLARE_COMPLETION_ONSTACK(complete);
	93	int ret;
	94
	95	BUG_ON(len % mtd->erasesize);
	96	if (logfs_super(sb)->s_flags & LOGFS_SB_FLAG_RO)
	97	return -EROFS;
	98
	99	memset(&ei, 0, sizeof(ei));
	100	ei.mtd = mtd;
	101	ei.addr = ofs;
	102	ei.len = len;
	103	ei.callback = logfs_erase_callback;
	104	ei.priv = (long)&complete;
	105	ret = mtd->erase(mtd, &ei);
	106	if (ret)
	107	return -EIO;
	108
	109	wait_for_completion(&complete);
	110	if (ei.state != MTD_ERASE_DONE)
	111	return -EIO;
	112	return mtd_erase_mapping(sb, ofs, len);
	113	}
	114
	115	static void mtd_sync(struct super_block *sb)
	116	{
	117	struct mtd_info *mtd = logfs_super(sb)->s_mtd;
	118
	119	if (mtd->sync)
	120	mtd->sync(mtd);
	121	}
	122
	123	static int mtd_readpage(void _sb, struct page page)
	124	{
	125	struct super_block *sb = _sb;
	126	int err;
	127
	128	err = mtd_read(sb, page->index << PAGE_SHIFT, PAGE_SIZE,
	129	page_address(page));
6f485b41 JE	130	if (err == -EUCLEAN \|\| err == -EBADMSG) {
6f485b41 JE	131	/* -EBADMSG happens regularly on power failures */
5db53f3e JE	132	err = 0;
	133	/* FIXME: force GC this segment */
	134	}
	135	if (err) {
	136	ClearPageUptodate(page);
	137	SetPageError(page);
	138	} else {
	139	SetPageUptodate(page);
	140	ClearPageError(page);
	141	}
	142	unlock_page(page);
	143	return err;
	144	}
	145
	146	static struct page mtd_find_first_sb(struct super_block sb, u64 *ofs)
	147	{
	148	struct logfs_super *super = logfs_super(sb);
	149	struct address_space *mapping = super->s_mapping_inode->i_mapping;
	150	filler_t *filler = mtd_readpage;
	151	struct mtd_info *mtd = super->s_mtd;
	152
	153	if (!mtd->block_isbad)
	154	return NULL;
	155
	156	*ofs = 0;
	157	while (mtd->block_isbad(mtd, *ofs)) {
	158	*ofs += mtd->erasesize;
	159	if (*ofs >= mtd->size)
	160	return NULL;
	161	}
	162	BUG_ON(*ofs & ~PAGE_MASK);
	163	return read_cache_page(mapping, *ofs >> PAGE_SHIFT, filler, sb);
	164	}
	165
	166	static struct page mtd_find_last_sb(struct super_block sb, u64 *ofs)
	167	{
	168	struct logfs_super *super = logfs_super(sb);
	169	struct address_space *mapping = super->s_mapping_inode->i_mapping;
	170	filler_t *filler = mtd_readpage;
	171	struct mtd_info *mtd = super->s_mtd;
	172
	173	if (!mtd->block_isbad)
	174	return NULL;
	175
	176	*ofs = mtd->size - mtd->erasesize;
	177	while (mtd->block_isbad(mtd, *ofs)) {
	178	*ofs -= mtd->erasesize;
	179	if (*ofs <= 0)
	180	return NULL;
	181	}
	182	ofs = ofs + mtd->erasesize - 0x1000;
	183	BUG_ON(*ofs & ~PAGE_MASK);
	184	return read_cache_page(mapping, *ofs >> PAGE_SHIFT, filler, sb);
	185	}
	186
	187	static int __mtd_writeseg(struct super_block *sb, u64 ofs, pgoff_t index,
	188	size_t nr_pages)
	189	{
	190	struct logfs_super *super = logfs_super(sb);
	191	struct address_space *mapping = super->s_mapping_inode->i_mapping;
	192	struct page *page;
	193	int i, err;
	194
	195	for (i = 0; i < nr_pages; i++) {
196	page = find_lock_page(mapping, index + i);
197	BUG_ON(!page);
198
199	err = mtd_write(sb, page->index << PAGE_SHIFT, PAGE_SIZE,
200	page_address(page));
201	unlock_page(page);
202	page_cache_release(page);
203	if (err)
204	return err;
205	}
206	return 0;
207	}
208
209	static void mtd_writeseg(struct super_block *sb, u64 ofs, size_t len)
210	{
211	struct logfs_super *super = logfs_super(sb);
212	int head;
213
214	if (super->s_flags & LOGFS_SB_FLAG_RO)
215	return;
216
217	if (len == 0) {
218	/* This can happen when the object fit perfectly into a
219	* segment, the segment gets written per sync and subsequently
220	* closed.
221	*/
222	return;
223	}
224	head = ofs & (PAGE_SIZE - 1);
225	if (head) {
226	ofs -= head;
227	len += head;
228	}
229	len = PAGE_ALIGN(len);
230	__mtd_writeseg(sb, ofs, ofs >> PAGE_SHIFT, len >> PAGE_SHIFT);
231	}
232
e5a0726a	233	static void mtd_put_device(struct logfs_super *s)
5db53f3e	234	{
e5a0726a	235	put_mtd_device(s->s_mtd);
5db53f3e JE	236	}
5db53f3e JE	237
6f485b41 JE	238	static int mtd_can_write_buf(struct super_block *sb, u64 ofs)
	239	{
	240	struct logfs_super *super = logfs_super(sb);
	241	void *buf;
	242	int err;
	243
	244	buf = kmalloc(super->s_writesize, GFP_KERNEL);
	245	if (!buf)
	246	return -ENOMEM;
	247	err = mtd_read(sb, ofs, super->s_writesize, buf);
	248	if (err)
	249	goto out;
	250	if (memchr_inv(buf, 0xff, super->s_writesize))
	251	err = -EIO;
	252	kfree(buf);
	253	out:
	254	return err;
	255	}
	256
5db53f3e JE	257	static const struct logfs_device_ops mtd_devops = {
	258	.find_first_sb = mtd_find_first_sb,
	259	.find_last_sb = mtd_find_last_sb,
	260	.readpage = mtd_readpage,
	261	.writeseg = mtd_writeseg,
	262	.erase = mtd_erase,
6f485b41	263	.can_write_buf = mtd_can_write_buf,
5db53f3e JE	264	.sync = mtd_sync,
	265	.put_device = mtd_put_device,
	266	};
	267
7d945a3a	268	int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr)
5db53f3e	269	{
0d85c799	270	struct mtd_info *mtd = get_mtd_device(NULL, mtdnr);
7d945a3a	271	if (IS_ERR(mtd))
ccf31c10	272	return PTR_ERR(mtd);
0d85c799 AV	273
	274	s->s_bdev = NULL;
	275	s->s_mtd = mtd;
	276	s->s_devops = &mtd_devops;
7d945a3a	277	return 0;
5db53f3e	278	}