[linux-2.6-block.git] / fs / omfs / inode.c

/*
 * Optimized MPEG FS - inode and super operations.
 * Copyright (C) 2006 Bob Copeland <me@bobcopeland.com>
 * Released under GPL v2.
 */
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/vfs.h>
#include <linux/parser.h>
#include <linux/buffer_head.h>
#include <linux/vmalloc.h>
#include <linux/writeback.h>
#include <linux/crc-itu-t.h>
#include "omfs.h"

MODULE_AUTHOR("Bob Copeland <me@bobcopeland.com>");
MODULE_DESCRIPTION("OMFS (ReplayTV/Karma) Filesystem for Linux");
MODULE_LICENSE("GPL");

struct buffer_head *omfs_bread(struct super_block *sb, sector_t block)
{
	struct omfs_sb_info *sbi = OMFS_SB(sb);
	if (block >= sbi->s_num_blocks)
		return NULL;

	return sb_bread(sb, clus_to_blk(sbi, block));
}

struct inode *omfs_new_inode(struct inode *dir, umode_t mode)
{
	struct inode *inode;
	u64 new_block;
	int err;
	int len;
	struct omfs_sb_info *sbi = OMFS_SB(dir->i_sb);

	inode = new_inode(dir->i_sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);

	err = omfs_allocate_range(dir->i_sb, sbi->s_mirrors, sbi->s_mirrors,
			&new_block, &len);
	if (err)
		goto fail;

	inode->i_ino = new_block;
	inode_init_owner(inode, NULL, mode);
	inode->i_mapping->a_ops = &omfs_aops;

	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
	switch (mode & S_IFMT) {
	case S_IFDIR:
		inode->i_op = &omfs_dir_inops;
		inode->i_fop = &omfs_dir_operations;
		inode->i_size = sbi->s_sys_blocksize;
		inc_nlink(inode);
		break;
	case S_IFREG:
		inode->i_op = &omfs_file_inops;
		inode->i_fop = &omfs_file_operations;
		inode->i_size = 0;
		break;
	}

	insert_inode_hash(inode);
	mark_inode_dirty(inode);
	return inode;
fail:
	make_bad_inode(inode);
	iput(inode);
	return ERR_PTR(err);
}

/*
 * Update the header checksums for a dirty inode based on its contents.
 * Caller is expected to hold the buffer head underlying oi and mark it
 * dirty.
 */
static void omfs_update_checksums(struct omfs_inode *oi)
{
	int xor, i, ofs = 0, count;
	u16 crc = 0;
	unsigned char *ptr = (unsigned char *) oi;

	count = be32_to_cpu(oi->i_head.h_body_size);
	ofs = sizeof(struct omfs_header);

	crc = crc_itu_t(crc, ptr + ofs, count);
	oi->i_head.h_crc = cpu_to_be16(crc);

	xor = ptr[0];
	for (i = 1; i < OMFS_XOR_COUNT; i++)
		xor ^= ptr[i];

	oi->i_head.h_check_xor = xor;
}

static int __omfs_write_inode(struct inode *inode, int wait)
{
	struct omfs_inode *oi;
	struct omfs_sb_info *sbi = OMFS_SB(inode->i_sb);
	struct buffer_head *bh, *bh2;
	u64 ctime;
	int i;
	int ret = -EIO;
	int sync_failed = 0;

	/* get current inode since we may have written sibling ptrs etc. */
	bh = omfs_bread(inode->i_sb, inode->i_ino);
	if (!bh)
		goto out;

	oi = (struct omfs_inode *) bh->b_data;

	oi->i_head.h_self = cpu_to_be64(inode->i_ino);
	if (S_ISDIR(inode->i_mode))
		oi->i_type = OMFS_DIR;
	else if (S_ISREG(inode->i_mode))
		oi->i_type = OMFS_FILE;
	else {
		printk(KERN_WARNING "omfs: unknown file type: %d\n",
			inode->i_mode);
		goto out_brelse;
	}

	oi->i_head.h_body_size = cpu_to_be32(sbi->s_sys_blocksize -
		sizeof(struct omfs_header));
	oi->i_head.h_version = 1;
	oi->i_head.h_type = OMFS_INODE_NORMAL;
	oi->i_head.h_magic = OMFS_IMAGIC;
	oi->i_size = cpu_to_be64(inode->i_size);

	ctime = inode->i_ctime.tv_sec * 1000LL +
		((inode->i_ctime.tv_nsec + 999)/1000);
	oi->i_ctime = cpu_to_be64(ctime);

	omfs_update_checksums(oi);

	mark_buffer_dirty(bh);
	if (wait) {
		sync_dirty_buffer(bh);
		if (buffer_req(bh) && !buffer_uptodate(bh))
			sync_failed = 1;
	}

	/* if mirroring writes, copy to next fsblock */
	for (i = 1; i < sbi->s_mirrors; i++) {
		bh2 = omfs_bread(inode->i_sb, inode->i_ino + i);
		if (!bh2)
			goto out_brelse;

		memcpy(bh2->b_data, bh->b_data, bh->b_size);
		mark_buffer_dirty(bh2);
		if (wait) {
			sync_dirty_buffer(bh2);
			if (buffer_req(bh2) && !buffer_uptodate(bh2))
				sync_failed = 1;
		}
		brelse(bh2);
	}
	ret = (sync_failed) ? -EIO : 0;
out_brelse:
	brelse(bh);
out:
	return ret;
}

static int omfs_write_inode(struct inode *inode, struct writeback_control *wbc)
{
	return __omfs_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
}

int omfs_sync_inode(struct inode *inode)
{
	return __omfs_write_inode(inode, 1);
}

/*
 * called when an entry is deleted, need to clear the bits in the
 * bitmaps.
 */
static void omfs_evict_inode(struct inode *inode)
{
	truncate_inode_pages_final(&inode->i_data);
	clear_inode(inode);

	if (inode->i_nlink)
		return;

	if (S_ISREG(inode->i_mode)) {
		inode->i_size = 0;
		omfs_shrink_inode(inode);
	}

	omfs_clear_range(inode->i_sb, inode->i_ino, 2);
}

struct inode *omfs_iget(struct super_block *sb, ino_t ino)
{
	struct omfs_sb_info *sbi = OMFS_SB(sb);
	struct omfs_inode *oi;
	struct buffer_head *bh;
	u64 ctime;
	unsigned long nsecs;
	struct inode *inode;

	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;

	bh = omfs_bread(inode->i_sb, ino);
	if (!bh)
		goto iget_failed;

	oi = (struct omfs_inode *)bh->b_data;

	/* check self */
	if (ino != be64_to_cpu(oi->i_head.h_self))
		goto fail_bh;

	inode->i_uid = sbi->s_uid;
	inode->i_gid = sbi->s_gid;

	ctime = be64_to_cpu(oi->i_ctime);
	nsecs = do_div(ctime, 1000) * 1000L;

	inode->i_atime.tv_sec = ctime;
	inode->i_mtime.tv_sec = ctime;
	inode->i_ctime.tv_sec = ctime;
	inode->i_atime.tv_nsec = nsecs;
	inode->i_mtime.tv_nsec = nsecs;
	inode->i_ctime.tv_nsec = nsecs;

	inode->i_mapping->a_ops = &omfs_aops;

	switch (oi->i_type) {
	case OMFS_DIR:
		inode->i_mode = S_IFDIR | (S_IRWXUGO & ~sbi->s_dmask);
		inode->i_op = &omfs_dir_inops;
		inode->i_fop = &omfs_dir_operations;
		inode->i_size = sbi->s_sys_blocksize;
		inc_nlink(inode);
		break;
	case OMFS_FILE:
		inode->i_mode = S_IFREG | (S_IRWXUGO & ~sbi->s_fmask);
		inode->i_fop = &omfs_file_operations;
		inode->i_size = be64_to_cpu(oi->i_size);
		break;
	}
	brelse(bh);
	unlock_new_inode(inode);
	return inode;
fail_bh:
	brelse(bh);
iget_failed:
	iget_failed(inode);
	return ERR_PTR(-EIO);
}

static void omfs_put_super(struct super_block *sb)
{
	struct omfs_sb_info *sbi = OMFS_SB(sb);
	kfree(sbi->s_imap);
	kfree(sbi);
	sb->s_fs_info = NULL;
}

static int omfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct super_block *s = dentry->d_sb;
	struct omfs_sb_info *sbi = OMFS_SB(s);
	u64 id = huge_encode_dev(s->s_bdev->bd_dev);

	buf->f_type = OMFS_MAGIC;
	buf->f_bsize = sbi->s_blocksize;
	buf->f_blocks = sbi->s_num_blocks;
	buf->f_files = sbi->s_num_blocks;
	buf->f_namelen = OMFS_NAMELEN;
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);

	buf->f_bfree = buf->f_bavail = buf->f_ffree =
		omfs_count_free(s);

	return 0;
}

static const struct super_operations omfs_sops = {
	.write_inode	= omfs_write_inode,
	.evict_inode	= omfs_evict_inode,
	.put_super	= omfs_put_super,
	.statfs		= omfs_statfs,
	.show_options	= generic_show_options,
};

/*
 * For Rio Karma, there is an on-disk free bitmap whose location is
 * stored in the root block.  For ReplayTV, there is no such free bitmap
 * so we have to walk the tree.  Both inodes and file data are allocated
 * from the same map.  This array can be big (300k) so we allocate
 * in units of the blocksize.
 */
static int omfs_get_imap(struct super_block *sb)
{
	int bitmap_size;
	int array_size;
	int count;
	struct omfs_sb_info *sbi = OMFS_SB(sb);
	struct buffer_head *bh;
	unsigned long **ptr;
	sector_t block;

	bitmap_size = DIV_ROUND_UP(sbi->s_num_blocks, 8);
	array_size = DIV_ROUND_UP(bitmap_size, sb->s_blocksize);

	if (sbi->s_bitmap_ino == ~0ULL)
		goto out;

	sbi->s_imap_size = array_size;
	sbi->s_imap = kcalloc(array_size, sizeof(unsigned long *), GFP_KERNEL);
	if (!sbi->s_imap)
		goto nomem;

	block = clus_to_blk(sbi, sbi->s_bitmap_ino);
	if (block >= sbi->s_num_blocks)
		goto nomem;

	ptr = sbi->s_imap;
	for (count = bitmap_size; count > 0; count -= sb->s_blocksize) {
		bh = sb_bread(sb, block++);
		if (!bh)
			goto nomem_free;
		*ptr = kmalloc(sb->s_blocksize, GFP_KERNEL);
		if (!*ptr) {
			brelse(bh);
			goto nomem_free;
		}
		memcpy(*ptr, bh->b_data, sb->s_blocksize);
		if (count < sb->s_blocksize)
			memset((void *)*ptr + count, 0xff,
				sb->s_blocksize - count);
		brelse(bh);
		ptr++;
	}
out:
	return 0;

nomem_free:
	for (count = 0; count < array_size; count++)
		kfree(sbi->s_imap[count]);

	kfree(sbi->s_imap);
nomem:
	sbi->s_imap = NULL;
	sbi->s_imap_size = 0;
	return -ENOMEM;
}

enum {
	Opt_uid, Opt_gid, Opt_umask, Opt_dmask, Opt_fmask
};

static const match_table_t tokens = {
	{Opt_uid, "uid=%u"},
	{Opt_gid, "gid=%u"},
	{Opt_umask, "umask=%o"},
	{Opt_dmask, "dmask=%o"},
	{Opt_fmask, "fmask=%o"},
};

static int parse_options(char *options, struct omfs_sb_info *sbi)
{
	char *p;
	substring_t args[MAX_OPT_ARGS];
	int option;

	if (!options)
		return 1;

	while ((p = strsep(&options, ",")) != NULL) {
		int token;
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_uid:
			if (match_int(&args[0], &option))
				return 0;
			sbi->s_uid = make_kuid(current_user_ns(), option);
			if (!uid_valid(sbi->s_uid))
				return 0;
			break;
		case Opt_gid:
			if (match_int(&args[0], &option))
				return 0;
			sbi->s_gid = make_kgid(current_user_ns(), option);
			if (!gid_valid(sbi->s_gid))
				return 0;
			break;
		case Opt_umask:
			if (match_octal(&args[0], &option))
				return 0;
			sbi->s_fmask = sbi->s_dmask = option;
			break;
		case Opt_dmask:
			if (match_octal(&args[0], &option))
				return 0;
			sbi->s_dmask = option;
			break;
		case Opt_fmask:
			if (match_octal(&args[0], &option))
				return 0;
			sbi->s_fmask = option;
			break;
		default:
			return 0;
		}
	}
	return 1;
}

static int omfs_fill_super(struct super_block *sb, void *data, int silent)
{
	struct buffer_head *bh, *bh2;
	struct omfs_super_block *omfs_sb;
	struct omfs_root_block *omfs_rb;
	struct omfs_sb_info *sbi;
	struct inode *root;
	int ret = -EINVAL;

	save_mount_options(sb, (char *) data);

	sbi = kzalloc(sizeof(struct omfs_sb_info), GFP_KERNEL);
	if (!sbi)
		return -ENOMEM;

	sb->s_fs_info = sbi;

	sbi->s_uid = current_uid();
	sbi->s_gid = current_gid();
	sbi->s_dmask = sbi->s_fmask = current_umask();

	if (!parse_options((char *) data, sbi))
		goto end;

	sb->s_maxbytes = 0xffffffff;

	sb_set_blocksize(sb, 0x200);

	bh = sb_bread(sb, 0);
	if (!bh)
		goto end;

	omfs_sb = (struct omfs_super_block *)bh->b_data;

	if (omfs_sb->s_magic != cpu_to_be32(OMFS_MAGIC)) {
		if (!silent)
			printk(KERN_ERR "omfs: Invalid superblock (%x)\n",
				   omfs_sb->s_magic);
		goto out_brelse_bh;
	}
	sb->s_magic = OMFS_MAGIC;

	sbi->s_num_blocks = be64_to_cpu(omfs_sb->s_num_blocks);
	sbi->s_blocksize = be32_to_cpu(omfs_sb->s_blocksize);
	sbi->s_mirrors = be32_to_cpu(omfs_sb->s_mirrors);
	sbi->s_root_ino = be64_to_cpu(omfs_sb->s_root_block);
	sbi->s_sys_blocksize = be32_to_cpu(omfs_sb->s_sys_blocksize);
	mutex_init(&sbi->s_bitmap_lock);

	if (sbi->s_sys_blocksize > PAGE_SIZE) {
		printk(KERN_ERR "omfs: sysblock size (%d) is out of range\n",
			sbi->s_sys_blocksize);
		goto out_brelse_bh;
	}

	if (sbi->s_blocksize < sbi->s_sys_blocksize ||
	    sbi->s_blocksize > OMFS_MAX_BLOCK_SIZE) {
		printk(KERN_ERR "omfs: block size (%d) is out of range\n",
			sbi->s_blocksize);
		goto out_brelse_bh;
	}

	/*
	 * Use sys_blocksize as the fs block since it is smaller than a
	 * page while the fs blocksize can be larger.
	 */
	sb_set_blocksize(sb, sbi->s_sys_blocksize);

	/*
	 * ...and the difference goes into a shift.  sys_blocksize is always
	 * a power of two factor of blocksize.
	 */
	sbi->s_block_shift = get_bitmask_order(sbi->s_blocksize) -
		get_bitmask_order(sbi->s_sys_blocksize);

	bh2 = omfs_bread(sb, be64_to_cpu(omfs_sb->s_root_block));
	if (!bh2)
		goto out_brelse_bh;

	omfs_rb = (struct omfs_root_block *)bh2->b_data;

	sbi->s_bitmap_ino = be64_to_cpu(omfs_rb->r_bitmap);
	sbi->s_clustersize = be32_to_cpu(omfs_rb->r_clustersize);

	if (sbi->s_num_blocks != be64_to_cpu(omfs_rb->r_num_blocks)) {
		printk(KERN_ERR "omfs: block count discrepancy between "
			"super and root blocks (%llx, %llx)\n",
			(unsigned long long)sbi->s_num_blocks,
			(unsigned long long)be64_to_cpu(omfs_rb->r_num_blocks));
		goto out_brelse_bh2;
	}

	if (sbi->s_bitmap_ino != ~0ULL &&
	    sbi->s_bitmap_ino > sbi->s_num_blocks) {
		printk(KERN_ERR "omfs: free space bitmap location is corrupt "
			"(%llx, total blocks %llx)\n",
			(unsigned long long) sbi->s_bitmap_ino,
			(unsigned long long) sbi->s_num_blocks);
		goto out_brelse_bh2;
	}
	if (sbi->s_clustersize < 1 ||
	    sbi->s_clustersize > OMFS_MAX_CLUSTER_SIZE) {
		printk(KERN_ERR "omfs: cluster size out of range (%d)",
			sbi->s_clustersize);
		goto out_brelse_bh2;
	}

	ret = omfs_get_imap(sb);
	if (ret)
		goto out_brelse_bh2;

	sb->s_op = &omfs_sops;

	root = omfs_iget(sb, be64_to_cpu(omfs_rb->r_root_dir));
	if (IS_ERR(root)) {
		ret = PTR_ERR(root);
		goto out_brelse_bh2;
	}

	sb->s_root = d_make_root(root);
	if (!sb->s_root)
		goto out_brelse_bh2;
	printk(KERN_DEBUG "omfs: Mounted volume %s\n", omfs_rb->r_name);

	ret = 0;
out_brelse_bh2:
	brelse(bh2);
out_brelse_bh:
	brelse(bh);
end:
	if (ret)
		kfree(sbi);
	return ret;
}

static struct dentry *omfs_mount(struct file_system_type *fs_type,
			int flags, const char *dev_name, void *data)
{
	return mount_bdev(fs_type, flags, dev_name, data, omfs_fill_super);
}

static struct file_system_type omfs_fs_type = {
	.owner = THIS_MODULE,
	.name = "omfs",
	.mount = omfs_mount,
	.kill_sb = kill_block_super,
	.fs_flags = FS_REQUIRES_DEV,
};
MODULE_ALIAS_FS("omfs");

static int __init init_omfs_fs(void)
{
	return register_filesystem(&omfs_fs_type);
}

static void __exit exit_omfs_fs(void)
{
	unregister_filesystem(&omfs_fs_type);
}

module_init(init_omfs_fs);
module_exit(exit_omfs_fs);
Commit	Line	Data
555e3775 BC	1	/*
	2	* Optimized MPEG FS - inode and super operations.
	3	* Copyright (C) 2006 Bob Copeland <me@bobcopeland.com>
	4	* Released under GPL v2.
	5	*/
555e3775 BC	6	#include <linux/module.h>
555e3775 BC	7	#include <linux/sched.h>
5a0e3ad6	8	#include <linux/slab.h>
555e3775 BC	9	#include <linux/fs.h>
	10	#include <linux/vfs.h>
	11	#include <linux/parser.h>
	12	#include <linux/buffer_head.h>
	13	#include <linux/vmalloc.h>
a9185b41	14	#include <linux/writeback.h>
555e3775 BC	15	#include <linux/crc-itu-t.h>
	16	#include "omfs.h"
	17
	18	MODULE_AUTHOR("Bob Copeland <me@bobcopeland.com>");
	19	MODULE_DESCRIPTION("OMFS (ReplayTV/Karma) Filesystem for Linux");
	20	MODULE_LICENSE("GPL");
	21
f068272c BC	22	struct buffer_head omfs_bread(struct super_block sb, sector_t block)
	23	{
	24	struct omfs_sb_info *sbi = OMFS_SB(sb);
	25	if (block >= sbi->s_num_blocks)
	26	return NULL;
	27
	28	return sb_bread(sb, clus_to_blk(sbi, block));
	29	}
	30
587228be	31	struct inode omfs_new_inode(struct inode dir, umode_t mode)
555e3775 BC	32	{
	33	struct inode *inode;
	34	u64 new_block;
	35	int err;
	36	int len;
	37	struct omfs_sb_info *sbi = OMFS_SB(dir->i_sb);
	38
	39	inode = new_inode(dir->i_sb);
	40	if (!inode)
	41	return ERR_PTR(-ENOMEM);
	42
	43	err = omfs_allocate_range(dir->i_sb, sbi->s_mirrors, sbi->s_mirrors,
	44	&new_block, &len);
	45	if (err)
	46	goto fail;
	47
	48	inode->i_ino = new_block;
6a9e652c	49	inode_init_owner(inode, NULL, mode);
555e3775 BC	50	inode->i_mapping->a_ops = &omfs_aops;
	51
	52	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
	53	switch (mode & S_IFMT) {
	54	case S_IFDIR:
	55	inode->i_op = &omfs_dir_inops;
	56	inode->i_fop = &omfs_dir_operations;
	57	inode->i_size = sbi->s_sys_blocksize;
	58	inc_nlink(inode);
	59	break;
	60	case S_IFREG:
	61	inode->i_op = &omfs_file_inops;
	62	inode->i_fop = &omfs_file_operations;
	63	inode->i_size = 0;
	64	break;
	65	}
	66
	67	insert_inode_hash(inode);
	68	mark_inode_dirty(inode);
	69	return inode;
	70	fail:
	71	make_bad_inode(inode);
	72	iput(inode);
	73	return ERR_PTR(err);
	74	}
	75
	76	/*
	77	* Update the header checksums for a dirty inode based on its contents.
	78	* Caller is expected to hold the buffer head underlying oi and mark it
	79	* dirty.
	80	*/
	81	static void omfs_update_checksums(struct omfs_inode *oi)
	82	{
	83	int xor, i, ofs = 0, count;
	84	u16 crc = 0;
	85	unsigned char ptr = (unsigned char ) oi;
	86
	87	count = be32_to_cpu(oi->i_head.h_body_size);
	88	ofs = sizeof(struct omfs_header);
	89
	90	crc = crc_itu_t(crc, ptr + ofs, count);
	91	oi->i_head.h_crc = cpu_to_be16(crc);
	92
	93	xor = ptr[0];
	94	for (i = 1; i < OMFS_XOR_COUNT; i++)
	95	xor ^= ptr[i];
	96
	97	oi->i_head.h_check_xor = xor;
	98	}
	99
a9185b41	100	static int __omfs_write_inode(struct inode *inode, int wait)
555e3775 BC	101	{
	102	struct omfs_inode *oi;
	103	struct omfs_sb_info *sbi = OMFS_SB(inode->i_sb);
	104	struct buffer_head bh, bh2;
555e3775 BC	105	u64 ctime;
	106	int i;
	107	int ret = -EIO;
	108	int sync_failed = 0;
	109
	110	/* get current inode since we may have written sibling ptrs etc. */
f068272c	111	bh = omfs_bread(inode->i_sb, inode->i_ino);
555e3775 BC	112	if (!bh)
	113	goto out;
	114
	115	oi = (struct omfs_inode *) bh->b_data;
	116
	117	oi->i_head.h_self = cpu_to_be64(inode->i_ino);
	118	if (S_ISDIR(inode->i_mode))
	119	oi->i_type = OMFS_DIR;
	120	else if (S_ISREG(inode->i_mode))
	121	oi->i_type = OMFS_FILE;
	122	else {
	123	printk(KERN_WARNING "omfs: unknown file type: %d\n",
	124	inode->i_mode);
	125	goto out_brelse;
	126	}
	127
	128	oi->i_head.h_body_size = cpu_to_be32(sbi->s_sys_blocksize -
	129	sizeof(struct omfs_header));
	130	oi->i_head.h_version = 1;
	131	oi->i_head.h_type = OMFS_INODE_NORMAL;
	132	oi->i_head.h_magic = OMFS_IMAGIC;
	133	oi->i_size = cpu_to_be64(inode->i_size);
	134
	135	ctime = inode->i_ctime.tv_sec * 1000LL +
	136	((inode->i_ctime.tv_nsec + 999)/1000);
	137	oi->i_ctime = cpu_to_be64(ctime);
	138
	139	omfs_update_checksums(oi);
	140
	141	mark_buffer_dirty(bh);
	142	if (wait) {
	143	sync_dirty_buffer(bh);
	144	if (buffer_req(bh) && !buffer_uptodate(bh))
	145	sync_failed = 1;
	146	}
	147
	148	/* if mirroring writes, copy to next fsblock */
	149	for (i = 1; i < sbi->s_mirrors; i++) {
f068272c	150	bh2 = omfs_bread(inode->i_sb, inode->i_ino + i);
555e3775 BC	151	if (!bh2)
	152	goto out_brelse;
	153
	154	memcpy(bh2->b_data, bh->b_data, bh->b_size);
	155	mark_buffer_dirty(bh2);
	156	if (wait) {
	157	sync_dirty_buffer(bh2);
	158	if (buffer_req(bh2) && !buffer_uptodate(bh2))
	159	sync_failed = 1;
	160	}
	161	brelse(bh2);
	162	}
	163	ret = (sync_failed) ? -EIO : 0;
	164	out_brelse:
	165	brelse(bh);
	166	out:
	167	return ret;
	168	}
	169
a9185b41 CH	170	static int omfs_write_inode(struct inode inode, struct writeback_control wbc)
	171	{
	172	return __omfs_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
	173	}
	174
555e3775 BC	175	int omfs_sync_inode(struct inode *inode)
555e3775 BC	176	{
a9185b41	177	return __omfs_write_inode(inode, 1);
555e3775 BC	178	}
	179
	180	/*
	181	* called when an entry is deleted, need to clear the bits in the
	182	* bitmaps.
	183	*/
69c9e750	184	static void omfs_evict_inode(struct inode *inode)
555e3775	185	{
91b0abe3	186	truncate_inode_pages_final(&inode->i_data);
dbd5768f	187	clear_inode(inode);
69c9e750 AV	188
	189	if (inode->i_nlink)
	190	return;
555e3775 BC	191
	192	if (S_ISREG(inode->i_mode)) {
	193	inode->i_size = 0;
	194	omfs_shrink_inode(inode);
	195	}
	196
	197	omfs_clear_range(inode->i_sb, inode->i_ino, 2);
555e3775 BC	198	}
	199
	200	struct inode omfs_iget(struct super_block sb, ino_t ino)
	201	{
	202	struct omfs_sb_info *sbi = OMFS_SB(sb);
	203	struct omfs_inode *oi;
	204	struct buffer_head *bh;
555e3775 BC	205	u64 ctime;
	206	unsigned long nsecs;
	207	struct inode *inode;
	208
	209	inode = iget_locked(sb, ino);
	210	if (!inode)
	211	return ERR_PTR(-ENOMEM);
	212	if (!(inode->i_state & I_NEW))
	213	return inode;
	214
f068272c	215	bh = omfs_bread(inode->i_sb, ino);
555e3775 BC	216	if (!bh)
	217	goto iget_failed;
	218
	219	oi = (struct omfs_inode *)bh->b_data;
	220
	221	/* check self */
	222	if (ino != be64_to_cpu(oi->i_head.h_self))
	223	goto fail_bh;
	224
	225	inode->i_uid = sbi->s_uid;
	226	inode->i_gid = sbi->s_gid;
	227
	228	ctime = be64_to_cpu(oi->i_ctime);
	229	nsecs = do_div(ctime, 1000) * 1000L;
	230
	231	inode->i_atime.tv_sec = ctime;
	232	inode->i_mtime.tv_sec = ctime;
	233	inode->i_ctime.tv_sec = ctime;
	234	inode->i_atime.tv_nsec = nsecs;
	235	inode->i_mtime.tv_nsec = nsecs;
	236	inode->i_ctime.tv_nsec = nsecs;
	237
	238	inode->i_mapping->a_ops = &omfs_aops;
	239
	240	switch (oi->i_type) {
	241	case OMFS_DIR:
	242	inode->i_mode = S_IFDIR \| (S_IRWXUGO & ~sbi->s_dmask);
	243	inode->i_op = &omfs_dir_inops;
	244	inode->i_fop = &omfs_dir_operations;
c963343a	245	inode->i_size = sbi->s_sys_blocksize;
555e3775 BC	246	inc_nlink(inode);
	247	break;
	248	case OMFS_FILE:
	249	inode->i_mode = S_IFREG \| (S_IRWXUGO & ~sbi->s_fmask);
	250	inode->i_fop = &omfs_file_operations;
	251	inode->i_size = be64_to_cpu(oi->i_size);
	252	break;
	253	}
	254	brelse(bh);
	255	unlock_new_inode(inode);
	256	return inode;
	257	fail_bh:
	258	brelse(bh);
	259	iget_failed:
	260	iget_failed(inode);
	261	return ERR_PTR(-EIO);
	262	}
	263
	264	static void omfs_put_super(struct super_block *sb)
	265	{
	266	struct omfs_sb_info *sbi = OMFS_SB(sb);
	267	kfree(sbi->s_imap);
	268	kfree(sbi);
	269	sb->s_fs_info = NULL;
	270	}
	271
	272	static int omfs_statfs(struct dentry dentry, struct kstatfs buf)
	273	{
	274	struct super_block *s = dentry->d_sb;
	275	struct omfs_sb_info *sbi = OMFS_SB(s);
197e671e CL	276	u64 id = huge_encode_dev(s->s_bdev->bd_dev);
197e671e CL	277
555e3775 BC	278	buf->f_type = OMFS_MAGIC;
	279	buf->f_bsize = sbi->s_blocksize;
	280	buf->f_blocks = sbi->s_num_blocks;
	281	buf->f_files = sbi->s_num_blocks;
	282	buf->f_namelen = OMFS_NAMELEN;
197e671e CL	283	buf->f_fsid.val[0] = (u32)id;
197e671e CL	284	buf->f_fsid.val[1] = (u32)(id >> 32);
555e3775 BC	285
	286	buf->f_bfree = buf->f_bavail = buf->f_ffree =
	287	omfs_count_free(s);
197e671e	288
555e3775 BC	289	return 0;
	290	}
	291
b87221de	292	static const struct super_operations omfs_sops = {
555e3775	293	.write_inode = omfs_write_inode,
69c9e750	294	.evict_inode = omfs_evict_inode,
555e3775 BC	295	.put_super = omfs_put_super,
	296	.statfs = omfs_statfs,
	297	.show_options = generic_show_options,
	298	};
	299
	300	/*
	301	* For Rio Karma, there is an on-disk free bitmap whose location is
	302	* stored in the root block. For ReplayTV, there is no such free bitmap
	303	* so we have to walk the tree. Both inodes and file data are allocated
	304	* from the same map. This array can be big (300k) so we allocate
	305	* in units of the blocksize.
	306	*/
	307	static int omfs_get_imap(struct super_block *sb)
	308	{
	309	int bitmap_size;
	310	int array_size;
	311	int count;
	312	struct omfs_sb_info *sbi = OMFS_SB(sb);
	313	struct buffer_head *bh;
	314	unsigned long **ptr;
	315	sector_t block;
	316
	317	bitmap_size = DIV_ROUND_UP(sbi->s_num_blocks, 8);
	318	array_size = DIV_ROUND_UP(bitmap_size, sb->s_blocksize);
	319
	320	if (sbi->s_bitmap_ino == ~0ULL)
	321	goto out;
	322
	323	sbi->s_imap_size = array_size;
998d6688	324	sbi->s_imap = kcalloc(array_size, sizeof(unsigned long *), GFP_KERNEL);
555e3775 BC	325	if (!sbi->s_imap)
	326	goto nomem;
	327
	328	block = clus_to_blk(sbi, sbi->s_bitmap_ino);
f068272c BC	329	if (block >= sbi->s_num_blocks)
	330	goto nomem;
	331
555e3775 BC	332	ptr = sbi->s_imap;
	333	for (count = bitmap_size; count > 0; count -= sb->s_blocksize) {
	334	bh = sb_bread(sb, block++);
	335	if (!bh)
	336	goto nomem_free;
	337	*ptr = kmalloc(sb->s_blocksize, GFP_KERNEL);
	338	if (!*ptr) {
	339	brelse(bh);
	340	goto nomem_free;
	341	}
	342	memcpy(*ptr, bh->b_data, sb->s_blocksize);
	343	if (count < sb->s_blocksize)
	344	memset((void )ptr + count, 0xff,
	345	sb->s_blocksize - count);
	346	brelse(bh);
	347	ptr++;
	348	}
	349	out:
	350	return 0;
	351
	352	nomem_free:
	353	for (count = 0; count < array_size; count++)
	354	kfree(sbi->s_imap[count]);
	355
	356	kfree(sbi->s_imap);
	357	nomem:
	358	sbi->s_imap = NULL;
	359	sbi->s_imap_size = 0;
	360	return -ENOMEM;
	361	}
	362
	363	enum {
	364	Opt_uid, Opt_gid, Opt_umask, Opt_dmask, Opt_fmask
	365	};
	366
a447c093	367	static const match_table_t tokens = {
555e3775 BC	368	{Opt_uid, "uid=%u"},
	369	{Opt_gid, "gid=%u"},
	370	{Opt_umask, "umask=%o"},
	371	{Opt_dmask, "dmask=%o"},
	372	{Opt_fmask, "fmask=%o"},
	373	};
	374
	375	static int parse_options(char options, struct omfs_sb_info sbi)
	376	{
	377	char *p;
	378	substring_t args[MAX_OPT_ARGS];
	379	int option;
	380
	381	if (!options)
	382	return 1;
	383
	384	while ((p = strsep(&options, ",")) != NULL) {
	385	int token;
	386	if (!*p)
	387	continue;
	388
	389	token = match_token(p, tokens, args);
	390	switch (token) {
	391	case Opt_uid:
	392	if (match_int(&args[0], &option))
	393	return 0;
80fcbe75 EB	394	sbi->s_uid = make_kuid(current_user_ns(), option);
	395	if (!uid_valid(sbi->s_uid))
	396	return 0;
555e3775 BC	397	break;
	398	case Opt_gid:
	399	if (match_int(&args[0], &option))
	400	return 0;
80fcbe75 EB	401	sbi->s_gid = make_kgid(current_user_ns(), option);
	402	if (!gid_valid(sbi->s_gid))
	403	return 0;
555e3775 BC	404	break;
	405	case Opt_umask:
	406	if (match_octal(&args[0], &option))
	407	return 0;
	408	sbi->s_fmask = sbi->s_dmask = option;
	409	break;
	410	case Opt_dmask:
	411	if (match_octal(&args[0], &option))
	412	return 0;
	413	sbi->s_dmask = option;
	414	break;
	415	case Opt_fmask:
	416	if (match_octal(&args[0], &option))
	417	return 0;
	418	sbi->s_fmask = option;
	419	break;
	420	default:
	421	return 0;
	422	}
	423	}
	424	return 1;
	425	}
	426
	427	static int omfs_fill_super(struct super_block sb, void data, int silent)
	428	{
	429	struct buffer_head bh, bh2;
	430	struct omfs_super_block *omfs_sb;
	431	struct omfs_root_block *omfs_rb;
	432	struct omfs_sb_info *sbi;
	433	struct inode *root;
555e3775 BC	434	int ret = -EINVAL;
	435
	436	save_mount_options(sb, (char *) data);
	437
	438	sbi = kzalloc(sizeof(struct omfs_sb_info), GFP_KERNEL);
	439	if (!sbi)
	440	return -ENOMEM;
	441
	442	sb->s_fs_info = sbi;
	443
c222d53e DH	444	sbi->s_uid = current_uid();
c222d53e DH	445	sbi->s_gid = current_gid();
ce3b0f8d	446	sbi->s_dmask = sbi->s_fmask = current_umask();
555e3775 BC	447
	448	if (!parse_options((char *) data, sbi))
	449	goto end;
	450
	451	sb->s_maxbytes = 0xffffffff;
	452
	453	sb_set_blocksize(sb, 0x200);
	454
	455	bh = sb_bread(sb, 0);
	456	if (!bh)
	457	goto end;
	458
	459	omfs_sb = (struct omfs_super_block *)bh->b_data;
	460
	461	if (omfs_sb->s_magic != cpu_to_be32(OMFS_MAGIC)) {
	462	if (!silent)
	463	printk(KERN_ERR "omfs: Invalid superblock (%x)\n",
	464	omfs_sb->s_magic);
	465	goto out_brelse_bh;
	466	}
	467	sb->s_magic = OMFS_MAGIC;
	468
	469	sbi->s_num_blocks = be64_to_cpu(omfs_sb->s_num_blocks);
	470	sbi->s_blocksize = be32_to_cpu(omfs_sb->s_blocksize);
	471	sbi->s_mirrors = be32_to_cpu(omfs_sb->s_mirrors);
	472	sbi->s_root_ino = be64_to_cpu(omfs_sb->s_root_block);
	473	sbi->s_sys_blocksize = be32_to_cpu(omfs_sb->s_sys_blocksize);
	474	mutex_init(&sbi->s_bitmap_lock);
	475
	476	if (sbi->s_sys_blocksize > PAGE_SIZE) {
	477	printk(KERN_ERR "omfs: sysblock size (%d) is out of range\n",
	478	sbi->s_sys_blocksize);
	479	goto out_brelse_bh;
	480	}
	481
	482	if (sbi->s_blocksize < sbi->s_sys_blocksize \|\|
	483	sbi->s_blocksize > OMFS_MAX_BLOCK_SIZE) {
	484	printk(KERN_ERR "omfs: block size (%d) is out of range\n",
	485	sbi->s_blocksize);
	486	goto out_brelse_bh;
	487	}
	488
	489	/*
	490	* Use sys_blocksize as the fs block since it is smaller than a
	491	* page while the fs blocksize can be larger.
	492	*/
	493	sb_set_blocksize(sb, sbi->s_sys_blocksize);
	494
	495	/*
	496	* ...and the difference goes into a shift. sys_blocksize is always
	497	* a power of two factor of blocksize.
	498	*/
	499	sbi->s_block_shift = get_bitmask_order(sbi->s_blocksize) -
	500	get_bitmask_order(sbi->s_sys_blocksize);
	501
f068272c	502	bh2 = omfs_bread(sb, be64_to_cpu(omfs_sb->s_root_block));
555e3775 BC	503	if (!bh2)
	504	goto out_brelse_bh;
	505
	506	omfs_rb = (struct omfs_root_block *)bh2->b_data;
	507
	508	sbi->s_bitmap_ino = be64_to_cpu(omfs_rb->r_bitmap);
	509	sbi->s_clustersize = be32_to_cpu(omfs_rb->r_clustersize);
	510
	511	if (sbi->s_num_blocks != be64_to_cpu(omfs_rb->r_num_blocks)) {
	512	printk(KERN_ERR "omfs: block count discrepancy between "
	513	"super and root blocks (%llx, %llx)\n",
dc60bf1d AB	514	(unsigned long long)sbi->s_num_blocks,
dc60bf1d AB	515	(unsigned long long)be64_to_cpu(omfs_rb->r_num_blocks));
555e3775 BC	516	goto out_brelse_bh2;
	517	}
	518
9442e54f BC	519	if (sbi->s_bitmap_ino != ~0ULL &&
	520	sbi->s_bitmap_ino > sbi->s_num_blocks) {
	521	printk(KERN_ERR "omfs: free space bitmap location is corrupt "
	522	"(%llx, total blocks %llx)\n",
	523	(unsigned long long) sbi->s_bitmap_ino,
	524	(unsigned long long) sbi->s_num_blocks);
	525	goto out_brelse_bh2;
	526	}
8800a044 BC	527	if (sbi->s_clustersize < 1 \|\|
	528	sbi->s_clustersize > OMFS_MAX_CLUSTER_SIZE) {
	529	printk(KERN_ERR "omfs: cluster size out of range (%d)",
	530	sbi->s_clustersize);
	531	goto out_brelse_bh2;
	532	}
9442e54f	533
555e3775 BC	534	ret = omfs_get_imap(sb);
	535	if (ret)
	536	goto out_brelse_bh2;
	537
	538	sb->s_op = &omfs_sops;
	539
	540	root = omfs_iget(sb, be64_to_cpu(omfs_rb->r_root_dir));
	541	if (IS_ERR(root)) {
	542	ret = PTR_ERR(root);
	543	goto out_brelse_bh2;
	544	}
	545
48fde701 AV	546	sb->s_root = d_make_root(root);
48fde701 AV	547	if (!sb->s_root)
555e3775	548	goto out_brelse_bh2;
555e3775 BC	549	printk(KERN_DEBUG "omfs: Mounted volume %s\n", omfs_rb->r_name);
	550
	551	ret = 0;
	552	out_brelse_bh2:
	553	brelse(bh2);
	554	out_brelse_bh:
	555	brelse(bh);
	556	end:
70d9e384 DB	557	if (ret)
70d9e384 DB	558	kfree(sbi);
555e3775 BC	559	return ret;
	560	}
	561
152a0836 AV	562	static struct dentry omfs_mount(struct file_system_type fs_type,
152a0836 AV	563	int flags, const char dev_name, void data)
555e3775	564	{
152a0836	565	return mount_bdev(fs_type, flags, dev_name, data, omfs_fill_super);
555e3775 BC	566	}
	567
	568	static struct file_system_type omfs_fs_type = {
	569	.owner = THIS_MODULE,
	570	.name = "omfs",
152a0836	571	.mount = omfs_mount,
555e3775 BC	572	.kill_sb = kill_block_super,
	573	.fs_flags = FS_REQUIRES_DEV,
	574	};
7f78e035	575	MODULE_ALIAS_FS("omfs");
555e3775 BC	576
	577	static int __init init_omfs_fs(void)
	578	{
	579	return register_filesystem(&omfs_fs_type);
	580	}
	581
	582	static void __exit exit_omfs_fs(void)
	583	{
	584	unregister_filesystem(&omfs_fs_type);
	585	}
	586
	587	module_init(init_omfs_fs);
	588	module_exit(exit_omfs_fs);