[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/version.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <linux/vfs.h>
#include <linux/parser.h>
#include <linux/buffer_head.h>
#include <linux/vmalloc.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 inode *omfs_new_inode(struct inode *dir, int 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->i_mode = mode;
	inode->i_uid = current->fsuid;
	inode->i_gid = current->fsgid;
	inode->i_blocks = 0;
	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;
	unsigned int block;
	u64 ctime;
	int i;
	int ret = -EIO;
	int sync_failed = 0;

	/* get current inode since we may have written sibling ptrs etc. */
	block = clus_to_blk(sbi, inode->i_ino);
	bh = sb_bread(inode->i_sb, block);
	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 = sb_bread(inode->i_sb, block + i *
			(sbi->s_blocksize / sbi->s_sys_blocksize));
		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;
}

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_delete_inode(struct inode *inode)
{
	truncate_inode_pages(&inode->i_data, 0);

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

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

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;
	unsigned int block;
	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;

	block = clus_to_blk(sbi, ino);
	bh = sb_bread(inode->i_sb, block);
	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 = be32_to_cpu(oi->i_head.h_body_size) +
			sizeof(struct omfs_header);
		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);
	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_bfree = buf->f_bavail = buf->f_ffree =
		omfs_count_free(s);
	return 0;
}

static struct super_operations omfs_sops = {
	.write_inode	= omfs_write_inode,
	.delete_inode	= omfs_delete_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 = kzalloc(array_size * sizeof(unsigned long *), GFP_KERNEL);
	if (!sbi->s_imap)
		goto nomem;

	block = clus_to_blk(sbi, sbi->s_bitmap_ino);
	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 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 = option;
			break;
		case Opt_gid:
			if (match_int(&args[0], &option))
				return 0;
			sbi->s_gid = option;
			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;
	sector_t start;
	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->fs->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);

	start = clus_to_blk(sbi, be64_to_cpu(omfs_sb->s_root_block));
	bh2 = sb_bread(sb, start);
	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",
			sbi->s_num_blocks, be64_to_cpu(omfs_rb->r_num_blocks));
		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_alloc_root(root);
	if (!sb->s_root) {
		iput(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:
	return ret;
}

static int omfs_get_sb(struct file_system_type *fs_type,
			int flags, const char *dev_name,
			void *data, struct vfsmount *m)
{
	return get_sb_bdev(fs_type, flags, dev_name, data, omfs_fill_super, m);
}

static struct file_system_type omfs_fs_type = {
	.owner = THIS_MODULE,
	.name = "omfs",
	.get_sb = omfs_get_sb,
	.kill_sb = kill_block_super,
	.fs_flags = FS_REQUIRES_DEV,
};

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