Release 4.7 fs/logfs/dev_mtd.c

Directory: fs/logfs
/*
 * 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 logfs_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;
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 82 97.62% 1 33.33%
artem bityutskiy artem bityutskiy 2 2.38% 2 66.67%
Total 84 100.00% 3 100.00%



static int loffs_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_SIZE);
	page_start = ofs & PAGE_MASK;
	page_end = PAGE_ALIGN(ofs + len) - 1;
	ret = mtd_write(mtd, ofs, len, &retlen, buf);
	if (ret || (retlen != len))
		return -EIO;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 153 96.84% 1 25.00%
kirill a. shutemov kirill a. shutemov 3 1.90% 1 25.00%
artem bityutskiy artem bityutskiy 2 1.27% 2 50.00%
Total 158 100.00% 4 100.00%

/*
 * 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 logfs_mtd_erase().  What an exercise in futility!
 */


static void logfs_erase_callback(struct erase_info *ei)
{
	complete((struct completion *)ei->priv);
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%



static int logfs_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);
		put_page(page);
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 106 98.15% 1 33.33%
artem bityutskiy artem bityutskiy 1 0.93% 1 33.33%
kirill a. shutemov kirill a. shutemov 1 0.93% 1 33.33%
Total 108 100.00% 3 100.00%



static int logfs_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 logfs_mtd_erase_mapping(sb, ofs, len);
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 158 98.14% 2 50.00%
artem bityutskiy artem bityutskiy 3 1.86% 2 50.00%
Total 161 100.00% 4 100.00%



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

	mtd_sync(mtd);
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 26 92.86% 1 33.33%
artem bityutskiy artem bityutskiy 2 7.14% 2 66.67%
Total 28 100.00% 3 100.00%



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

	err = logfs_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;
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 100 98.04% 2 66.67%
artem bityutskiy artem bityutskiy 2 1.96% 1 33.33%
Total 102 100.00% 3 100.00%



static struct page *logfs_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 = logfs_mtd_readpage;
	struct mtd_info *mtd = super->s_mtd;

	*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);
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 110 97.35% 1 33.33%
artem bityutskiy artem bityutskiy 3 2.65% 2 66.67%
Total 113 100.00% 3 100.00%



static struct page *logfs_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 = logfs_mtd_readpage;
	struct mtd_info *mtd = super->s_mtd;

	*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);
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 126 97.67% 1 33.33%
artem bityutskiy artem bityutskiy 3 2.33% 2 66.67%
Total 129 100.00% 3 100.00%



static int __logfs_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 = loffs_mtd_write(sb, page->index << PAGE_SHIFT, PAGE_SIZE,
					page_address(page));
		unlock_page(page);
		put_page(page);
		if (err)
			return err;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 120 97.56% 1 33.33%
artem bityutskiy artem bityutskiy 2 1.63% 1 33.33%
kirill a. shutemov kirill a. shutemov 1 0.81% 1 33.33%
Total 123 100.00% 3 100.00%



static void logfs_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);
	__logfs_mtd_writeseg(sb, ofs, ofs >> PAGE_SHIFT, len >> PAGE_SHIFT);
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 93 97.89% 1 50.00%
artem bityutskiy artem bityutskiy 2 2.11% 1 50.00%
Total 95 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 14 77.78% 1 33.33%
al viro al viro 3 16.67% 1 33.33%
artem bityutskiy artem bityutskiy 1 5.56% 1 33.33%
Total 18 100.00% 3 100.00%



static int logfs_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 = logfs_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;
}

Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 99 98.02% 1 50.00%
artem bityutskiy artem bityutskiy 2 1.98% 1 50.00%
Total 101 100.00% 2 100.00%


static const struct logfs_device_ops mtd_devops = {
	.find_first_sb	= logfs_mtd_find_first_sb,
	.find_last_sb	= logfs_mtd_find_last_sb,
	.readpage	= logfs_mtd_readpage,
	.writeseg	= logfs_mtd_writeseg,
	.erase		= logfs_mtd_erase,
	.can_write_buf	= logfs_mtd_can_write_buf,
	.sync		= logfs_mtd_sync,
	.put_device	= logfs_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;
}
Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 25 41.67% 3 60.00%
joern engel joern engel 22 36.67% 1 20.00%
dan carpenter dan carpenter 13 21.67% 1 20.00%
Total 60 100.00% 5 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
joern engel joern engel 1295 94.18% 3 20.00%
artem bityutskiy artem bityutskiy 34 2.47% 6 40.00%
al viro al viro 28 2.04% 4 26.67%
dan carpenter dan carpenter 13 0.95% 1 6.67%
kirill a. shutemov kirill a. shutemov 5 0.36% 1 6.67%
Total 1375 100.00% 15 100.00%
  Directory: fs/logfs

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
joern engel	joern engel	82	97.62%	1	33.33%
artem bityutskiy	artem bityutskiy	2	2.38%	2	66.67%
	Total	84	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 fs/logfs/dev_mtd.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
