[linux.git] / fs / omfs / inode.c

/*
 * Optimized MPEG FS - inode and super operations.
 * Copyright (C) 2006 Bob Copeland <[email protected]>
 * 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/cred.h>
#include <linux/parser.h>
#include <linux/buffer_head.h>
#include <linux/vmalloc.h>
#include <linux/writeback.h>
#include <linux/seq_file.h>
#include <linux/crc-itu-t.h>
#include "omfs.h"

MODULE_AUTHOR("Bob Copeland <[email protected]>");
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(inode);
	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;
}

/*
 * Display the mount options in /proc/mounts.
 */
static int omfs_show_options(struct seq_file *m, struct dentry *root)
{
	struct omfs_sb_info *sbi = OMFS_SB(root->d_sb);
	umode_t cur_umask = current_umask();

	if (!uid_eq(sbi->s_uid, current_uid()))
		seq_printf(m, ",uid=%u",
			   from_kuid_munged(&init_user_ns, sbi->s_uid));
	if (!gid_eq(sbi->s_gid, current_gid()))
		seq_printf(m, ",gid=%u",
			   from_kgid_munged(&init_user_ns, sbi->s_gid));

	if (sbi->s_dmask == sbi->s_fmask) {
		if (sbi->s_fmask != cur_umask)
			seq_printf(m, ",umask=%o", sbi->s_fmask);
	} else {
		if (sbi->s_dmask != cur_umask)
			seq_printf(m, ",dmask=%o", sbi->s_dmask);
		if (sbi->s_fmask != cur_umask)
			seq_printf(m, ",fmask=%o", sbi->s_fmask);
	}

	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	= omfs_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)
{
	unsigned int bitmap_size, 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, Opt_err
};

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"},
	{Opt_err, NULL},
};

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;

	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_num_blocks > OMFS_MAX_BLOCKS) {
		printk(KERN_ERR "omfs: sysblock number (%llx) is out of range\n",
		       (unsigned long long)sbi->s_num_blocks);
		goto out_brelse_bh;
	}

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