[net-next-2.6.git] / fs / minix / inode.c

/*
 *  linux/fs/minix/inode.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  Copyright (C) 1996  Gertjan van Wingerde
 *	Minix V2 fs support.
 *
 *  Modified for 680x0 by Andreas Schwab
 *  Updated to filesystem version 3 by Daniel Aragones
 */

#include <linux/module.h>
#include "minix.h"
#include <linux/buffer_head.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/highuid.h>
#include <linux/vfs.h>

static int minix_write_inode(struct inode * inode, int wait);
static int minix_statfs(struct dentry *dentry, struct kstatfs *buf);
static int minix_remount (struct super_block * sb, int * flags, char * data);

static void minix_delete_inode(struct inode *inode)
{
	truncate_inode_pages(&inode->i_data, 0);
	inode->i_size = 0;
	minix_truncate(inode);
	minix_free_inode(inode);
}

static void minix_put_super(struct super_block *sb)
{
	int i;
	struct minix_sb_info *sbi = minix_sb(sb);

	lock_kernel();

	if (!(sb->s_flags & MS_RDONLY)) {
		if (sbi->s_version != MINIX_V3)	 /* s_state is now out from V3 sb */
			sbi->s_ms->s_state = sbi->s_mount_state;
		mark_buffer_dirty(sbi->s_sbh);
	}
	for (i = 0; i < sbi->s_imap_blocks; i++)
		brelse(sbi->s_imap[i]);
	for (i = 0; i < sbi->s_zmap_blocks; i++)
		brelse(sbi->s_zmap[i]);
	brelse (sbi->s_sbh);
	kfree(sbi->s_imap);
	sb->s_fs_info = NULL;
	kfree(sbi);

	unlock_kernel();
}

static struct kmem_cache * minix_inode_cachep;

static struct inode *minix_alloc_inode(struct super_block *sb)
{
	struct minix_inode_info *ei;
	ei = (struct minix_inode_info *)kmem_cache_alloc(minix_inode_cachep, GFP_KERNEL);
	if (!ei)
		return NULL;
	return &ei->vfs_inode;
}

static void minix_destroy_inode(struct inode *inode)
{
	kmem_cache_free(minix_inode_cachep, minix_i(inode));
}

static void init_once(void *foo)
{
	struct minix_inode_info *ei = (struct minix_inode_info *) foo;

	inode_init_once(&ei->vfs_inode);
}

static int init_inodecache(void)
{
	minix_inode_cachep = kmem_cache_create("minix_inode_cache",
					     sizeof(struct minix_inode_info),
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
					     init_once);
	if (minix_inode_cachep == NULL)
		return -ENOMEM;
	return 0;
}

static void destroy_inodecache(void)
{
	kmem_cache_destroy(minix_inode_cachep);
}

static const struct super_operations minix_sops = {
	.alloc_inode	= minix_alloc_inode,
	.destroy_inode	= minix_destroy_inode,
	.write_inode	= minix_write_inode,
	.delete_inode	= minix_delete_inode,
	.put_super	= minix_put_super,
	.statfs		= minix_statfs,
	.remount_fs	= minix_remount,
};

static int minix_remount (struct super_block * sb, int * flags, char * data)
{
	struct minix_sb_info * sbi = minix_sb(sb);
	struct minix_super_block * ms;

	ms = sbi->s_ms;
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
		return 0;
	if (*flags & MS_RDONLY) {
		if (ms->s_state & MINIX_VALID_FS ||
		    !(sbi->s_mount_state & MINIX_VALID_FS))
			return 0;
		/* Mounting a rw partition read-only. */
		if (sbi->s_version != MINIX_V3)
			ms->s_state = sbi->s_mount_state;
		mark_buffer_dirty(sbi->s_sbh);
	} else {
	  	/* Mount a partition which is read-only, read-write. */
		if (sbi->s_version != MINIX_V3) {
			sbi->s_mount_state = ms->s_state;
			ms->s_state &= ~MINIX_VALID_FS;
		} else {
			sbi->s_mount_state = MINIX_VALID_FS;
		}
		mark_buffer_dirty(sbi->s_sbh);

		if (!(sbi->s_mount_state & MINIX_VALID_FS))
			printk("MINIX-fs warning: remounting unchecked fs, "
				"running fsck is recommended\n");
		else if ((sbi->s_mount_state & MINIX_ERROR_FS))
			printk("MINIX-fs warning: remounting fs with errors, "
				"running fsck is recommended\n");
	}
	return 0;
}

static int minix_fill_super(struct super_block *s, void *data, int silent)
{
	struct buffer_head *bh;
	struct buffer_head **map;
	struct minix_super_block *ms;
	struct minix3_super_block *m3s = NULL;
	unsigned long i, block;
	struct inode *root_inode;
	struct minix_sb_info *sbi;
	int ret = -EINVAL;

	sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
	if (!sbi)
		return -ENOMEM;
	s->s_fs_info = sbi;

	BUILD_BUG_ON(32 != sizeof (struct minix_inode));
	BUILD_BUG_ON(64 != sizeof(struct minix2_inode));

	if (!sb_set_blocksize(s, BLOCK_SIZE))
		goto out_bad_hblock;

	if (!(bh = sb_bread(s, 1)))
		goto out_bad_sb;

	ms = (struct minix_super_block *) bh->b_data;
	sbi->s_ms = ms;
	sbi->s_sbh = bh;
	sbi->s_mount_state = ms->s_state;
	sbi->s_ninodes = ms->s_ninodes;
	sbi->s_nzones = ms->s_nzones;
	sbi->s_imap_blocks = ms->s_imap_blocks;
	sbi->s_zmap_blocks = ms->s_zmap_blocks;
	sbi->s_firstdatazone = ms->s_firstdatazone;
	sbi->s_log_zone_size = ms->s_log_zone_size;
	sbi->s_max_size = ms->s_max_size;
	s->s_magic = ms->s_magic;
	if (s->s_magic == MINIX_SUPER_MAGIC) {
		sbi->s_version = MINIX_V1;
		sbi->s_dirsize = 16;
		sbi->s_namelen = 14;
		sbi->s_link_max = MINIX_LINK_MAX;
	} else if (s->s_magic == MINIX_SUPER_MAGIC2) {
		sbi->s_version = MINIX_V1;
		sbi->s_dirsize = 32;
		sbi->s_namelen = 30;
		sbi->s_link_max = MINIX_LINK_MAX;
	} else if (s->s_magic == MINIX2_SUPER_MAGIC) {
		sbi->s_version = MINIX_V2;
		sbi->s_nzones = ms->s_zones;
		sbi->s_dirsize = 16;
		sbi->s_namelen = 14;
		sbi->s_link_max = MINIX2_LINK_MAX;
	} else if (s->s_magic == MINIX2_SUPER_MAGIC2) {
		sbi->s_version = MINIX_V2;
		sbi->s_nzones = ms->s_zones;
		sbi->s_dirsize = 32;
		sbi->s_namelen = 30;
		sbi->s_link_max = MINIX2_LINK_MAX;
	} else if ( *(__u16 *)(bh->b_data + 24) == MINIX3_SUPER_MAGIC) {
		m3s = (struct minix3_super_block *) bh->b_data;
		s->s_magic = m3s->s_magic;
		sbi->s_imap_blocks = m3s->s_imap_blocks;
		sbi->s_zmap_blocks = m3s->s_zmap_blocks;
		sbi->s_firstdatazone = m3s->s_firstdatazone;
		sbi->s_log_zone_size = m3s->s_log_zone_size;
		sbi->s_max_size = m3s->s_max_size;
		sbi->s_ninodes = m3s->s_ninodes;
		sbi->s_nzones = m3s->s_zones;
		sbi->s_dirsize = 64;
		sbi->s_namelen = 60;
		sbi->s_version = MINIX_V3;
		sbi->s_link_max = MINIX2_LINK_MAX;
		sbi->s_mount_state = MINIX_VALID_FS;
		sb_set_blocksize(s, m3s->s_blocksize);
	} else
		goto out_no_fs;

	/*
	 * Allocate the buffer map to keep the superblock small.
	 */
	if (sbi->s_imap_blocks == 0 || sbi->s_zmap_blocks == 0)
		goto out_illegal_sb;
	i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) * sizeof(bh);
	map = kzalloc(i, GFP_KERNEL);
	if (!map)
		goto out_no_map;
	sbi->s_imap = &map[0];
	sbi->s_zmap = &map[sbi->s_imap_blocks];

	block=2;
	for (i=0 ; i < sbi->s_imap_blocks ; i++) {
		if (!(sbi->s_imap[i]=sb_bread(s, block)))
			goto out_no_bitmap;
		block++;
	}
	for (i=0 ; i < sbi->s_zmap_blocks ; i++) {
		if (!(sbi->s_zmap[i]=sb_bread(s, block)))
			goto out_no_bitmap;
		block++;
	}

	minix_set_bit(0,sbi->s_imap[0]->b_data);
	minix_set_bit(0,sbi->s_zmap[0]->b_data);

	/* set up enough so that it can read an inode */
	s->s_op = &minix_sops;
	root_inode = minix_iget(s, MINIX_ROOT_INO);
	if (IS_ERR(root_inode)) {
		ret = PTR_ERR(root_inode);
		goto out_no_root;
	}

	ret = -ENOMEM;
	s->s_root = d_alloc_root(root_inode);
	if (!s->s_root)
		goto out_iput;

	if (!(s->s_flags & MS_RDONLY)) {
		if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
			ms->s_state &= ~MINIX_VALID_FS;
		mark_buffer_dirty(bh);
	}
	if (!(sbi->s_mount_state & MINIX_VALID_FS))
		printk("MINIX-fs: mounting unchecked file system, "
			"running fsck is recommended\n");
 	else if (sbi->s_mount_state & MINIX_ERROR_FS)
		printk("MINIX-fs: mounting file system with errors, "
			"running fsck is recommended\n");
	return 0;

out_iput:
	iput(root_inode);
	goto out_freemap;

out_no_root:
	if (!silent)
		printk("MINIX-fs: get root inode failed\n");
	goto out_freemap;

out_no_bitmap:
	printk("MINIX-fs: bad superblock or unable to read bitmaps\n");
out_freemap:
	for (i = 0; i < sbi->s_imap_blocks; i++)
		brelse(sbi->s_imap[i]);
	for (i = 0; i < sbi->s_zmap_blocks; i++)
		brelse(sbi->s_zmap[i]);
	kfree(sbi->s_imap);
	goto out_release;

out_no_map:
	ret = -ENOMEM;
	if (!silent)
		printk("MINIX-fs: can't allocate map\n");
	goto out_release;

out_illegal_sb:
	if (!silent)
		printk("MINIX-fs: bad superblock\n");
	goto out_release;

out_no_fs:
	if (!silent)
		printk("VFS: Can't find a Minix filesystem V1 | V2 | V3 "
		       "on device %s.\n", s->s_id);
out_release:
	brelse(bh);
	goto out;

out_bad_hblock:
	printk("MINIX-fs: blocksize too small for device\n");
	goto out;

out_bad_sb:
	printk("MINIX-fs: unable to read superblock\n");
out:
	s->s_fs_info = NULL;
	kfree(sbi);
	return ret;
}

static int minix_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct super_block *sb = dentry->d_sb;
	struct minix_sb_info *sbi = minix_sb(sb);
	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
	buf->f_type = sb->s_magic;
	buf->f_bsize = sb->s_blocksize;
	buf->f_blocks = (sbi->s_nzones - sbi->s_firstdatazone) << sbi->s_log_zone_size;
	buf->f_bfree = minix_count_free_blocks(sbi);
	buf->f_bavail = buf->f_bfree;
	buf->f_files = sbi->s_ninodes;
	buf->f_ffree = minix_count_free_inodes(sbi);
	buf->f_namelen = sbi->s_namelen;
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);

	return 0;
}

static int minix_get_block(struct inode *inode, sector_t block,
		    struct buffer_head *bh_result, int create)
{
	if (INODE_VERSION(inode) == MINIX_V1)
		return V1_minix_get_block(inode, block, bh_result, create);
	else
		return V2_minix_get_block(inode, block, bh_result, create);
}

static int minix_writepage(struct page *page, struct writeback_control *wbc)
{
	return block_write_full_page(page, minix_get_block, wbc);
}

static int minix_readpage(struct file *file, struct page *page)
{
	return block_read_full_page(page,minix_get_block);
}

int __minix_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
{
	return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
				minix_get_block);
}

static int minix_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
{
	*pagep = NULL;
	return __minix_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
}

static sector_t minix_bmap(struct address_space *mapping, sector_t block)
{
	return generic_block_bmap(mapping,block,minix_get_block);
}

static const struct address_space_operations minix_aops = {
	.readpage = minix_readpage,
	.writepage = minix_writepage,
	.sync_page = block_sync_page,
	.write_begin = minix_write_begin,
	.write_end = generic_write_end,
	.bmap = minix_bmap
};

static const struct inode_operations minix_symlink_inode_operations = {
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
	.getattr	= minix_getattr,
};

void minix_set_inode(struct inode *inode, dev_t rdev)
{
	if (S_ISREG(inode->i_mode)) {
		inode->i_op = &minix_file_inode_operations;
		inode->i_fop = &minix_file_operations;
		inode->i_mapping->a_ops = &minix_aops;
	} else if (S_ISDIR(inode->i_mode)) {
		inode->i_op = &minix_dir_inode_operations;
		inode->i_fop = &minix_dir_operations;
		inode->i_mapping->a_ops = &minix_aops;
	} else if (S_ISLNK(inode->i_mode)) {
		inode->i_op = &minix_symlink_inode_operations;
		inode->i_mapping->a_ops = &minix_aops;
	} else
		init_special_inode(inode, inode->i_mode, rdev);
}

/*
 * The minix V1 function to read an inode.
 */
static struct inode *V1_minix_iget(struct inode *inode)
{
	struct buffer_head * bh;
	struct minix_inode * raw_inode;
	struct minix_inode_info *minix_inode = minix_i(inode);
	int i;

	raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
	if (!raw_inode) {
		iget_failed(inode);
		return ERR_PTR(-EIO);
	}
	inode->i_mode = raw_inode->i_mode;
	inode->i_uid = (uid_t)raw_inode->i_uid;
	inode->i_gid = (gid_t)raw_inode->i_gid;
	inode->i_nlink = raw_inode->i_nlinks;
	inode->i_size = raw_inode->i_size;
	inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = raw_inode->i_time;
	inode->i_mtime.tv_nsec = 0;
	inode->i_atime.tv_nsec = 0;
	inode->i_ctime.tv_nsec = 0;
	inode->i_blocks = 0;
	for (i = 0; i < 9; i++)
		minix_inode->u.i1_data[i] = raw_inode->i_zone[i];
	minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
	brelse(bh);
	unlock_new_inode(inode);
	return inode;
}

/*
 * The minix V2 function to read an inode.
 */
static struct inode *V2_minix_iget(struct inode *inode)
{
	struct buffer_head * bh;
	struct minix2_inode * raw_inode;
	struct minix_inode_info *minix_inode = minix_i(inode);
	int i;

	raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
	if (!raw_inode) {
		iget_failed(inode);
		return ERR_PTR(-EIO);
	}
	inode->i_mode = raw_inode->i_mode;
	inode->i_uid = (uid_t)raw_inode->i_uid;
	inode->i_gid = (gid_t)raw_inode->i_gid;
	inode->i_nlink = raw_inode->i_nlinks;
	inode->i_size = raw_inode->i_size;
	inode->i_mtime.tv_sec = raw_inode->i_mtime;
	inode->i_atime.tv_sec = raw_inode->i_atime;
	inode->i_ctime.tv_sec = raw_inode->i_ctime;
	inode->i_mtime.tv_nsec = 0;
	inode->i_atime.tv_nsec = 0;
	inode->i_ctime.tv_nsec = 0;
	inode->i_blocks = 0;
	for (i = 0; i < 10; i++)
		minix_inode->u.i2_data[i] = raw_inode->i_zone[i];
	minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
	brelse(bh);
	unlock_new_inode(inode);
	return inode;
}

/*
 * The global function to read an inode.
 */
struct inode *minix_iget(struct super_block *sb, unsigned long ino)
{
	struct inode *inode;

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

	if (INODE_VERSION(inode) == MINIX_V1)
		return V1_minix_iget(inode);
	else
		return V2_minix_iget(inode);
}

/*
 * The minix V1 function to synchronize an inode.
 */
static struct buffer_head * V1_minix_update_inode(struct inode * inode)
{
	struct buffer_head * bh;
	struct minix_inode * raw_inode;
	struct minix_inode_info *minix_inode = minix_i(inode);
	int i;

	raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
	if (!raw_inode)
		return NULL;
	raw_inode->i_mode = inode->i_mode;
	raw_inode->i_uid = fs_high2lowuid(inode->i_uid);
	raw_inode->i_gid = fs_high2lowgid(inode->i_gid);
	raw_inode->i_nlinks = inode->i_nlink;
	raw_inode->i_size = inode->i_size;
	raw_inode->i_time = inode->i_mtime.tv_sec;
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
		raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
	else for (i = 0; i < 9; i++)
		raw_inode->i_zone[i] = minix_inode->u.i1_data[i];
	mark_buffer_dirty(bh);
	return bh;
}

/*
 * The minix V2 function to synchronize an inode.
 */
static struct buffer_head * V2_minix_update_inode(struct inode * inode)
{
	struct buffer_head * bh;
	struct minix2_inode * raw_inode;
	struct minix_inode_info *minix_inode = minix_i(inode);
	int i;

	raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
	if (!raw_inode)
		return NULL;
	raw_inode->i_mode = inode->i_mode;
	raw_inode->i_uid = fs_high2lowuid(inode->i_uid);
	raw_inode->i_gid = fs_high2lowgid(inode->i_gid);
	raw_inode->i_nlinks = inode->i_nlink;
	raw_inode->i_size = inode->i_size;
	raw_inode->i_mtime = inode->i_mtime.tv_sec;
	raw_inode->i_atime = inode->i_atime.tv_sec;
	raw_inode->i_ctime = inode->i_ctime.tv_sec;
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
		raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
	else for (i = 0; i < 10; i++)
		raw_inode->i_zone[i] = minix_inode->u.i2_data[i];
	mark_buffer_dirty(bh);
	return bh;
}

static struct buffer_head *minix_update_inode(struct inode *inode)
{
	if (INODE_VERSION(inode) == MINIX_V1)
		return V1_minix_update_inode(inode);
	else
		return V2_minix_update_inode(inode);
}

static int minix_write_inode(struct inode * inode, int wait)
{
	brelse(minix_update_inode(inode));
	return 0;
}

int minix_sync_inode(struct inode * inode)
{
	int err = 0;
	struct buffer_head *bh;

	bh = minix_update_inode(inode);
	if (bh && buffer_dirty(bh))
	{
		sync_dirty_buffer(bh);
		if (buffer_req(bh) && !buffer_uptodate(bh))
		{
			printk("IO error syncing minix inode [%s:%08lx]\n",
				inode->i_sb->s_id, inode->i_ino);
			err = -1;
		}
	}
	else if (!bh)
		err = -1;
	brelse (bh);
	return err;
}

int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
	struct inode *dir = dentry->d_parent->d_inode;
	struct super_block *sb = dir->i_sb;
	generic_fillattr(dentry->d_inode, stat);
	if (INODE_VERSION(dentry->d_inode) == MINIX_V1)
		stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
	else
		stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
	stat->blksize = sb->s_blocksize;
	return 0;
}

/*
 * The function that is called for file truncation.
 */
void minix_truncate(struct inode * inode)
{
	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)))
		return;
	if (INODE_VERSION(inode) == MINIX_V1)
		V1_minix_truncate(inode);
	else
		V2_minix_truncate(inode);
}

static int minix_get_sb(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
{
	return get_sb_bdev(fs_type, flags, dev_name, data, minix_fill_super,
			   mnt);
}

static struct file_system_type minix_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "minix",
	.get_sb		= minix_get_sb,
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
};

static int __init init_minix_fs(void)
{
	int err = init_inodecache();
	if (err)
		goto out1;
	err = register_filesystem(&minix_fs_type);
	if (err)
		goto out;
	return 0;
out:
	destroy_inodecache();
out1:
	return err;
}

static void __exit exit_minix_fs(void)
{
        unregister_filesystem(&minix_fs_type);
	destroy_inodecache();
}

module_init(init_minix_fs)
module_exit(exit_minix_fs)
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/minix/inode.c
	3	*
	4	* Copyright (C) 1991, 1992 Linus Torvalds
	5	*
f762dd68	6	* Copyright (C) 1996 Gertjan van Wingerde
1da177e4 LT	7	* Minix V2 fs support.
	8	*
	9	* Modified for 680x0 by Andreas Schwab
939b00df	10	* Updated to filesystem version 3 by Daniel Aragones
1da177e4 LT	11	*/
	12
	13	#include <linux/module.h>
	14	#include "minix.h"
	15	#include <linux/buffer_head.h>
	16	#include <linux/slab.h>
	17	#include <linux/init.h>
	18	#include <linux/highuid.h>
	19	#include <linux/vfs.h>
	20
1da177e4	21	static int minix_write_inode(struct inode * inode, int wait);
726c3342	22	static int minix_statfs(struct dentry dentry, struct kstatfs buf);
1da177e4 LT	23	static int minix_remount (struct super_block * sb, int * flags, char * data);
	24
	25	static void minix_delete_inode(struct inode *inode)
	26	{
fef26658	27	truncate_inode_pages(&inode->i_data, 0);
1da177e4 LT	28	inode->i_size = 0;
	29	minix_truncate(inode);
	30	minix_free_inode(inode);
	31	}
	32
	33	static void minix_put_super(struct super_block *sb)
	34	{
	35	int i;
	36	struct minix_sb_info *sbi = minix_sb(sb);
	37
6cfd0148 CH	38	lock_kernel();
6cfd0148 CH	39
1da177e4	40	if (!(sb->s_flags & MS_RDONLY)) {
939b00df AB	41	if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
939b00df AB	42	sbi->s_ms->s_state = sbi->s_mount_state;
1da177e4 LT	43	mark_buffer_dirty(sbi->s_sbh);
	44	}
	45	for (i = 0; i < sbi->s_imap_blocks; i++)
	46	brelse(sbi->s_imap[i]);
	47	for (i = 0; i < sbi->s_zmap_blocks; i++)
	48	brelse(sbi->s_zmap[i]);
	49	brelse (sbi->s_sbh);
	50	kfree(sbi->s_imap);
	51	sb->s_fs_info = NULL;
	52	kfree(sbi);
	53
6cfd0148	54	unlock_kernel();
1da177e4 LT	55	}
1da177e4 LT	56
e18b890b	57	static struct kmem_cache * minix_inode_cachep;
1da177e4 LT	58
	59	static struct inode minix_alloc_inode(struct super_block sb)
	60	{
	61	struct minix_inode_info *ei;
e94b1766	62	ei = (struct minix_inode_info *)kmem_cache_alloc(minix_inode_cachep, GFP_KERNEL);
1da177e4 LT	63	if (!ei)
	64	return NULL;
	65	return &ei->vfs_inode;
	66	}
	67
	68	static void minix_destroy_inode(struct inode *inode)
	69	{
	70	kmem_cache_free(minix_inode_cachep, minix_i(inode));
	71	}
	72
51cc5068	73	static void init_once(void *foo)
1da177e4 LT	74	{
	75	struct minix_inode_info ei = (struct minix_inode_info ) foo;
	76
a35afb83	77	inode_init_once(&ei->vfs_inode);
1da177e4	78	}
20c2df83	79
1da177e4 LT	80	static int init_inodecache(void)
	81	{
	82	minix_inode_cachep = kmem_cache_create("minix_inode_cache",
	83	sizeof(struct minix_inode_info),
fffb60f9 PJ	84	0, (SLAB_RECLAIM_ACCOUNT\|
fffb60f9 PJ	85	SLAB_MEM_SPREAD),
20c2df83	86	init_once);
1da177e4 LT	87	if (minix_inode_cachep == NULL)
	88	return -ENOMEM;
	89	return 0;
	90	}
	91
	92	static void destroy_inodecache(void)
	93	{
1a1d92c1	94	kmem_cache_destroy(minix_inode_cachep);
1da177e4 LT	95	}
1da177e4 LT	96
ee9b6d61	97	static const struct super_operations minix_sops = {
1da177e4 LT	98	.alloc_inode = minix_alloc_inode,
1da177e4 LT	99	.destroy_inode = minix_destroy_inode,
1da177e4 LT	100	.write_inode = minix_write_inode,
	101	.delete_inode = minix_delete_inode,
	102	.put_super = minix_put_super,
	103	.statfs = minix_statfs,
	104	.remount_fs = minix_remount,
	105	};
	106
	107	static int minix_remount (struct super_block * sb, int * flags, char * data)
	108	{
	109	struct minix_sb_info * sbi = minix_sb(sb);
	110	struct minix_super_block * ms;
	111
	112	ms = sbi->s_ms;
	113	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
	114	return 0;
	115	if (*flags & MS_RDONLY) {
	116	if (ms->s_state & MINIX_VALID_FS \|\|
	117	!(sbi->s_mount_state & MINIX_VALID_FS))
	118	return 0;
	119	/* Mounting a rw partition read-only. */
939b00df AB	120	if (sbi->s_version != MINIX_V3)
939b00df AB	121	ms->s_state = sbi->s_mount_state;
1da177e4 LT	122	mark_buffer_dirty(sbi->s_sbh);
	123	} else {
	124	/* Mount a partition which is read-only, read-write. */
939b00df AB	125	if (sbi->s_version != MINIX_V3) {
	126	sbi->s_mount_state = ms->s_state;
	127	ms->s_state &= ~MINIX_VALID_FS;
	128	} else {
	129	sbi->s_mount_state = MINIX_VALID_FS;
	130	}
1da177e4 LT	131	mark_buffer_dirty(sbi->s_sbh);
	132
	133	if (!(sbi->s_mount_state & MINIX_VALID_FS))
11b84487 DV	134	printk("MINIX-fs warning: remounting unchecked fs, "
11b84487 DV	135	"running fsck is recommended\n");
1da177e4	136	else if ((sbi->s_mount_state & MINIX_ERROR_FS))
11b84487 DV	137	printk("MINIX-fs warning: remounting fs with errors, "
11b84487 DV	138	"running fsck is recommended\n");
1da177e4 LT	139	}
	140	return 0;
	141	}
	142
	143	static int minix_fill_super(struct super_block s, void data, int silent)
	144	{
	145	struct buffer_head *bh;
	146	struct buffer_head **map;
	147	struct minix_super_block *ms;
939b00df AB	148	struct minix3_super_block *m3s = NULL;
939b00df AB	149	unsigned long i, block;
1da177e4 LT	150	struct inode *root_inode;
1da177e4 LT	151	struct minix_sb_info *sbi;
a90a0880	152	int ret = -EINVAL;
1da177e4	153
f8314dc6	154	sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
1da177e4 LT	155	if (!sbi)
	156	return -ENOMEM;
	157	s->s_fs_info = sbi;
1da177e4	158
2ecd05ae AD	159	BUILD_BUG_ON(32 != sizeof (struct minix_inode));
2ecd05ae AD	160	BUILD_BUG_ON(64 != sizeof(struct minix2_inode));
1da177e4 LT	161
	162	if (!sb_set_blocksize(s, BLOCK_SIZE))
	163	goto out_bad_hblock;
	164
	165	if (!(bh = sb_bread(s, 1)))
	166	goto out_bad_sb;
	167
	168	ms = (struct minix_super_block *) bh->b_data;
	169	sbi->s_ms = ms;
	170	sbi->s_sbh = bh;
	171	sbi->s_mount_state = ms->s_state;
	172	sbi->s_ninodes = ms->s_ninodes;
	173	sbi->s_nzones = ms->s_nzones;
	174	sbi->s_imap_blocks = ms->s_imap_blocks;
	175	sbi->s_zmap_blocks = ms->s_zmap_blocks;
	176	sbi->s_firstdatazone = ms->s_firstdatazone;
	177	sbi->s_log_zone_size = ms->s_log_zone_size;
	178	sbi->s_max_size = ms->s_max_size;
	179	s->s_magic = ms->s_magic;
	180	if (s->s_magic == MINIX_SUPER_MAGIC) {
	181	sbi->s_version = MINIX_V1;
	182	sbi->s_dirsize = 16;
	183	sbi->s_namelen = 14;
	184	sbi->s_link_max = MINIX_LINK_MAX;
	185	} else if (s->s_magic == MINIX_SUPER_MAGIC2) {
	186	sbi->s_version = MINIX_V1;
	187	sbi->s_dirsize = 32;
	188	sbi->s_namelen = 30;
	189	sbi->s_link_max = MINIX_LINK_MAX;
	190	} else if (s->s_magic == MINIX2_SUPER_MAGIC) {
	191	sbi->s_version = MINIX_V2;
	192	sbi->s_nzones = ms->s_zones;
	193	sbi->s_dirsize = 16;
	194	sbi->s_namelen = 14;
	195	sbi->s_link_max = MINIX2_LINK_MAX;
	196	} else if (s->s_magic == MINIX2_SUPER_MAGIC2) {
	197	sbi->s_version = MINIX_V2;
	198	sbi->s_nzones = ms->s_zones;
	199	sbi->s_dirsize = 32;
	200	sbi->s_namelen = 30;
	201	sbi->s_link_max = MINIX2_LINK_MAX;
939b00df AB	202	} else if ( (__u16 )(bh->b_data + 24) == MINIX3_SUPER_MAGIC) {
	203	m3s = (struct minix3_super_block *) bh->b_data;
	204	s->s_magic = m3s->s_magic;
	205	sbi->s_imap_blocks = m3s->s_imap_blocks;
	206	sbi->s_zmap_blocks = m3s->s_zmap_blocks;
	207	sbi->s_firstdatazone = m3s->s_firstdatazone;
	208	sbi->s_log_zone_size = m3s->s_log_zone_size;
	209	sbi->s_max_size = m3s->s_max_size;
	210	sbi->s_ninodes = m3s->s_ninodes;
	211	sbi->s_nzones = m3s->s_zones;
	212	sbi->s_dirsize = 64;
	213	sbi->s_namelen = 60;
	214	sbi->s_version = MINIX_V3;
	215	sbi->s_link_max = MINIX2_LINK_MAX;
	216	sbi->s_mount_state = MINIX_VALID_FS;
	217	sb_set_blocksize(s, m3s->s_blocksize);
1da177e4 LT	218	} else
	219	goto out_no_fs;
	220
	221	/*
	222	* Allocate the buffer map to keep the superblock small.
	223	*/
f5fb09fa AB	224	if (sbi->s_imap_blocks == 0 \|\| sbi->s_zmap_blocks == 0)
f5fb09fa AB	225	goto out_illegal_sb;
1da177e4	226	i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) * sizeof(bh);
f8314dc6	227	map = kzalloc(i, GFP_KERNEL);
1da177e4 LT	228	if (!map)
1da177e4 LT	229	goto out_no_map;
1da177e4 LT	230	sbi->s_imap = &map[0];
	231	sbi->s_zmap = &map[sbi->s_imap_blocks];
	232
	233	block=2;
	234	for (i=0 ; i < sbi->s_imap_blocks ; i++) {
	235	if (!(sbi->s_imap[i]=sb_bread(s, block)))
	236	goto out_no_bitmap;
	237	block++;
	238	}
	239	for (i=0 ; i < sbi->s_zmap_blocks ; i++) {
	240	if (!(sbi->s_zmap[i]=sb_bread(s, block)))
	241	goto out_no_bitmap;
	242	block++;
	243	}
	244
	245	minix_set_bit(0,sbi->s_imap[0]->b_data);
	246	minix_set_bit(0,sbi->s_zmap[0]->b_data);
	247
	248	/* set up enough so that it can read an inode */
	249	s->s_op = &minix_sops;
a90a0880 DH	250	root_inode = minix_iget(s, MINIX_ROOT_INO);
	251	if (IS_ERR(root_inode)) {
	252	ret = PTR_ERR(root_inode);
1da177e4	253	goto out_no_root;
a90a0880	254	}
1da177e4	255
a90a0880	256	ret = -ENOMEM;
1da177e4 LT	257	s->s_root = d_alloc_root(root_inode);
	258	if (!s->s_root)
	259	goto out_iput;
	260
1da177e4	261	if (!(s->s_flags & MS_RDONLY)) {
939b00df AB	262	if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
939b00df AB	263	ms->s_state &= ~MINIX_VALID_FS;
1da177e4 LT	264	mark_buffer_dirty(bh);
	265	}
	266	if (!(sbi->s_mount_state & MINIX_VALID_FS))
11b84487 DV	267	printk("MINIX-fs: mounting unchecked file system, "
11b84487 DV	268	"running fsck is recommended\n");
1da177e4	269	else if (sbi->s_mount_state & MINIX_ERROR_FS)
11b84487 DV	270	printk("MINIX-fs: mounting file system with errors, "
11b84487 DV	271	"running fsck is recommended\n");
1da177e4 LT	272	return 0;
	273
	274	out_iput:
	275	iput(root_inode);
	276	goto out_freemap;
	277
	278	out_no_root:
	279	if (!silent)
	280	printk("MINIX-fs: get root inode failed\n");
	281	goto out_freemap;
	282
	283	out_no_bitmap:
	284	printk("MINIX-fs: bad superblock or unable to read bitmaps\n");
f5fb09fa	285	out_freemap:
1da177e4 LT	286	for (i = 0; i < sbi->s_imap_blocks; i++)
	287	brelse(sbi->s_imap[i]);
	288	for (i = 0; i < sbi->s_zmap_blocks; i++)
	289	brelse(sbi->s_zmap[i]);
	290	kfree(sbi->s_imap);
	291	goto out_release;
	292
	293	out_no_map:
a90a0880	294	ret = -ENOMEM;
1da177e4	295	if (!silent)
11b84487	296	printk("MINIX-fs: can't allocate map\n");
1da177e4 LT	297	goto out_release;
1da177e4 LT	298
f5fb09fa AB	299	out_illegal_sb:
	300	if (!silent)
	301	printk("MINIX-fs: bad superblock\n");
	302	goto out_release;
	303
1da177e4 LT	304	out_no_fs:
1da177e4 LT	305	if (!silent)
939b00df AB	306	printk("VFS: Can't find a Minix filesystem V1 \| V2 \| V3 "
939b00df AB	307	"on device %s.\n", s->s_id);
f5fb09fa	308	out_release:
1da177e4 LT	309	brelse(bh);
	310	goto out;
	311
	312	out_bad_hblock:
11b84487	313	printk("MINIX-fs: blocksize too small for device\n");
1da177e4 LT	314	goto out;
	315
	316	out_bad_sb:
	317	printk("MINIX-fs: unable to read superblock\n");
f5fb09fa	318	out:
1da177e4 LT	319	s->s_fs_info = NULL;
1da177e4 LT	320	kfree(sbi);
a90a0880	321	return ret;
1da177e4 LT	322	}
1da177e4 LT	323
726c3342	324	static int minix_statfs(struct dentry dentry, struct kstatfs buf)
1da177e4	325	{
054475d2 CL	326	struct super_block *sb = dentry->d_sb;
	327	struct minix_sb_info *sbi = minix_sb(sb);
	328	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
	329	buf->f_type = sb->s_magic;
	330	buf->f_bsize = sb->s_blocksize;
1da177e4 LT	331	buf->f_blocks = (sbi->s_nzones - sbi->s_firstdatazone) << sbi->s_log_zone_size;
	332	buf->f_bfree = minix_count_free_blocks(sbi);
	333	buf->f_bavail = buf->f_bfree;
	334	buf->f_files = sbi->s_ninodes;
	335	buf->f_ffree = minix_count_free_inodes(sbi);
	336	buf->f_namelen = sbi->s_namelen;
054475d2 CL	337	buf->f_fsid.val[0] = (u32)id;
	338	buf->f_fsid.val[1] = (u32)(id >> 32);
	339
1da177e4 LT	340	return 0;
	341	}
	342
	343	static int minix_get_block(struct inode *inode, sector_t block,
	344	struct buffer_head *bh_result, int create)
	345	{
	346	if (INODE_VERSION(inode) == MINIX_V1)
	347	return V1_minix_get_block(inode, block, bh_result, create);
	348	else
	349	return V2_minix_get_block(inode, block, bh_result, create);
	350	}
	351
	352	static int minix_writepage(struct page page, struct writeback_control wbc)
	353	{
	354	return block_write_full_page(page, minix_get_block, wbc);
	355	}
4a66af9e	356
1da177e4 LT	357	static int minix_readpage(struct file file, struct page page)
	358	{
	359	return block_read_full_page(page,minix_get_block);
	360	}
4a66af9e NP	361
	362	int __minix_write_begin(struct file file, struct address_space mapping,
	363	loff_t pos, unsigned len, unsigned flags,
	364	struct page pagep, void fsdata)
1da177e4	365	{
4a66af9e NP	366	return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
4a66af9e NP	367	minix_get_block);
1da177e4	368	}
4a66af9e NP	369
	370	static int minix_write_begin(struct file file, struct address_space mapping,
	371	loff_t pos, unsigned len, unsigned flags,
	372	struct page pagep, void fsdata)
	373	{
	374	*pagep = NULL;
	375	return __minix_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
	376	}
	377
1da177e4 LT	378	static sector_t minix_bmap(struct address_space *mapping, sector_t block)
	379	{
	380	return generic_block_bmap(mapping,block,minix_get_block);
	381	}
4a66af9e	382
f5e54d6e	383	static const struct address_space_operations minix_aops = {
1da177e4 LT	384	.readpage = minix_readpage,
	385	.writepage = minix_writepage,
	386	.sync_page = block_sync_page,
4a66af9e NP	387	.write_begin = minix_write_begin,
4a66af9e NP	388	.write_end = generic_write_end,
1da177e4 LT	389	.bmap = minix_bmap
	390	};
	391
92e1d5be	392	static const struct inode_operations minix_symlink_inode_operations = {
1da177e4 LT	393	.readlink = generic_readlink,
	394	.follow_link = page_follow_link_light,
	395	.put_link = page_put_link,
	396	.getattr = minix_getattr,
	397	};
	398
	399	void minix_set_inode(struct inode *inode, dev_t rdev)
	400	{
	401	if (S_ISREG(inode->i_mode)) {
	402	inode->i_op = &minix_file_inode_operations;
	403	inode->i_fop = &minix_file_operations;
	404	inode->i_mapping->a_ops = &minix_aops;
	405	} else if (S_ISDIR(inode->i_mode)) {
	406	inode->i_op = &minix_dir_inode_operations;
	407	inode->i_fop = &minix_dir_operations;
	408	inode->i_mapping->a_ops = &minix_aops;
	409	} else if (S_ISLNK(inode->i_mode)) {
	410	inode->i_op = &minix_symlink_inode_operations;
	411	inode->i_mapping->a_ops = &minix_aops;
	412	} else
	413	init_special_inode(inode, inode->i_mode, rdev);
	414	}
	415
	416	/*
	417	* The minix V1 function to read an inode.
	418	*/
a90a0880	419	static struct inode V1_minix_iget(struct inode inode)
1da177e4 LT	420	{
	421	struct buffer_head * bh;
	422	struct minix_inode * raw_inode;
	423	struct minix_inode_info *minix_inode = minix_i(inode);
	424	int i;
	425
	426	raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
	427	if (!raw_inode) {
a90a0880 DH	428	iget_failed(inode);
a90a0880 DH	429	return ERR_PTR(-EIO);
1da177e4 LT	430	}
	431	inode->i_mode = raw_inode->i_mode;
	432	inode->i_uid = (uid_t)raw_inode->i_uid;
	433	inode->i_gid = (gid_t)raw_inode->i_gid;
	434	inode->i_nlink = raw_inode->i_nlinks;
	435	inode->i_size = raw_inode->i_size;
	436	inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = raw_inode->i_time;
	437	inode->i_mtime.tv_nsec = 0;
	438	inode->i_atime.tv_nsec = 0;
	439	inode->i_ctime.tv_nsec = 0;
ba52de12	440	inode->i_blocks = 0;
1da177e4 LT	441	for (i = 0; i < 9; i++)
	442	minix_inode->u.i1_data[i] = raw_inode->i_zone[i];
	443	minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
	444	brelse(bh);
a90a0880 DH	445	unlock_new_inode(inode);
a90a0880 DH	446	return inode;
1da177e4 LT	447	}
	448
	449	/*
	450	* The minix V2 function to read an inode.
	451	*/
a90a0880	452	static struct inode V2_minix_iget(struct inode inode)
1da177e4 LT	453	{
	454	struct buffer_head * bh;
	455	struct minix2_inode * raw_inode;
	456	struct minix_inode_info *minix_inode = minix_i(inode);
	457	int i;
	458
	459	raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
	460	if (!raw_inode) {
a90a0880 DH	461	iget_failed(inode);
a90a0880 DH	462	return ERR_PTR(-EIO);
1da177e4 LT	463	}
	464	inode->i_mode = raw_inode->i_mode;
	465	inode->i_uid = (uid_t)raw_inode->i_uid;
	466	inode->i_gid = (gid_t)raw_inode->i_gid;
	467	inode->i_nlink = raw_inode->i_nlinks;
	468	inode->i_size = raw_inode->i_size;
	469	inode->i_mtime.tv_sec = raw_inode->i_mtime;
	470	inode->i_atime.tv_sec = raw_inode->i_atime;
	471	inode->i_ctime.tv_sec = raw_inode->i_ctime;
	472	inode->i_mtime.tv_nsec = 0;
	473	inode->i_atime.tv_nsec = 0;
	474	inode->i_ctime.tv_nsec = 0;
ba52de12	475	inode->i_blocks = 0;
1da177e4 LT	476	for (i = 0; i < 10; i++)
	477	minix_inode->u.i2_data[i] = raw_inode->i_zone[i];
	478	minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
	479	brelse(bh);
a90a0880 DH	480	unlock_new_inode(inode);
a90a0880 DH	481	return inode;
1da177e4 LT	482	}
	483
	484	/*
	485	* The global function to read an inode.
	486	*/
a90a0880	487	struct inode minix_iget(struct super_block sb, unsigned long ino)
1da177e4	488	{
a90a0880 DH	489	struct inode *inode;
	490
	491	inode = iget_locked(sb, ino);
	492	if (!inode)
	493	return ERR_PTR(-ENOMEM);
	494	if (!(inode->i_state & I_NEW))
	495	return inode;
	496
1da177e4	497	if (INODE_VERSION(inode) == MINIX_V1)
a90a0880	498	return V1_minix_iget(inode);
1da177e4	499	else
a90a0880	500	return V2_minix_iget(inode);
1da177e4 LT	501	}
	502
	503	/*
	504	* The minix V1 function to synchronize an inode.
	505	*/
	506	static struct buffer_head * V1_minix_update_inode(struct inode * inode)
	507	{
	508	struct buffer_head * bh;
	509	struct minix_inode * raw_inode;
	510	struct minix_inode_info *minix_inode = minix_i(inode);
	511	int i;
	512
	513	raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
	514	if (!raw_inode)
	515	return NULL;
	516	raw_inode->i_mode = inode->i_mode;
	517	raw_inode->i_uid = fs_high2lowuid(inode->i_uid);
	518	raw_inode->i_gid = fs_high2lowgid(inode->i_gid);
	519	raw_inode->i_nlinks = inode->i_nlink;
	520	raw_inode->i_size = inode->i_size;
	521	raw_inode->i_time = inode->i_mtime.tv_sec;
	522	if (S_ISCHR(inode->i_mode) \|\| S_ISBLK(inode->i_mode))
	523	raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
	524	else for (i = 0; i < 9; i++)
	525	raw_inode->i_zone[i] = minix_inode->u.i1_data[i];
	526	mark_buffer_dirty(bh);
	527	return bh;
	528	}
	529
	530	/*
	531	* The minix V2 function to synchronize an inode.
	532	*/
	533	static struct buffer_head * V2_minix_update_inode(struct inode * inode)
	534	{
	535	struct buffer_head * bh;
	536	struct minix2_inode * raw_inode;
	537	struct minix_inode_info *minix_inode = minix_i(inode);
	538	int i;
	539
	540	raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
	541	if (!raw_inode)
	542	return NULL;
	543	raw_inode->i_mode = inode->i_mode;
	544	raw_inode->i_uid = fs_high2lowuid(inode->i_uid);
	545	raw_inode->i_gid = fs_high2lowgid(inode->i_gid);
	546	raw_inode->i_nlinks = inode->i_nlink;
	547	raw_inode->i_size = inode->i_size;
	548	raw_inode->i_mtime = inode->i_mtime.tv_sec;
	549	raw_inode->i_atime = inode->i_atime.tv_sec;
	550	raw_inode->i_ctime = inode->i_ctime.tv_sec;
	551	if (S_ISCHR(inode->i_mode) \|\| S_ISBLK(inode->i_mode))
	552	raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
	553	else for (i = 0; i < 10; i++)
	554	raw_inode->i_zone[i] = minix_inode->u.i2_data[i];
	555	mark_buffer_dirty(bh);
	556	return bh;
	557	}
	558
	559	static struct buffer_head minix_update_inode(struct inode inode)
	560	{
	561	if (INODE_VERSION(inode) == MINIX_V1)
	562	return V1_minix_update_inode(inode);
	563	else
	564	return V2_minix_update_inode(inode);
565	}
566
567	static int minix_write_inode(struct inode * inode, int wait)
568	{
569	brelse(minix_update_inode(inode));
570	return 0;
571	}
572
573	int minix_sync_inode(struct inode * inode)
574	{
575	int err = 0;
576	struct buffer_head *bh;
577
578	bh = minix_update_inode(inode);
579	if (bh && buffer_dirty(bh))
580	{
581	sync_dirty_buffer(bh);
582	if (buffer_req(bh) && !buffer_uptodate(bh))
583	{
11b84487	584	printk("IO error syncing minix inode [%s:%08lx]\n",
1da177e4 LT	585	inode->i_sb->s_id, inode->i_ino);
	586	err = -1;
	587	}
	588	}
	589	else if (!bh)
	590	err = -1;
	591	brelse (bh);
	592	return err;
	593	}
	594
	595	int minix_getattr(struct vfsmount mnt, struct dentry dentry, struct kstat *stat)
	596	{
939b00df AB	597	struct inode *dir = dentry->d_parent->d_inode;
939b00df AB	598	struct super_block *sb = dir->i_sb;
1da177e4 LT	599	generic_fillattr(dentry->d_inode, stat);
1da177e4 LT	600	if (INODE_VERSION(dentry->d_inode) == MINIX_V1)
939b00df	601	stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
1da177e4	602	else
939b00df AB	603	stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
939b00df AB	604	stat->blksize = sb->s_blocksize;
1da177e4 LT	605	return 0;
	606	}
	607
	608	/*
	609	* The function that is called for file truncation.
	610	*/
	611	void minix_truncate(struct inode * inode)
	612	{
	613	if (!(S_ISREG(inode->i_mode) \|\| S_ISDIR(inode->i_mode) \|\| S_ISLNK(inode->i_mode)))
	614	return;
	615	if (INODE_VERSION(inode) == MINIX_V1)
	616	V1_minix_truncate(inode);
	617	else
	618	V2_minix_truncate(inode);
	619	}
	620
454e2398 DH	621	static int minix_get_sb(struct file_system_type *fs_type,
454e2398 DH	622	int flags, const char dev_name, void data, struct vfsmount *mnt)
1da177e4	623	{
454e2398 DH	624	return get_sb_bdev(fs_type, flags, dev_name, data, minix_fill_super,
454e2398 DH	625	mnt);
1da177e4 LT	626	}
	627
	628	static struct file_system_type minix_fs_type = {
	629	.owner = THIS_MODULE,
	630	.name = "minix",
	631	.get_sb = minix_get_sb,
	632	.kill_sb = kill_block_super,
	633	.fs_flags = FS_REQUIRES_DEV,
	634	};
	635
	636	static int __init init_minix_fs(void)
	637	{
	638	int err = init_inodecache();
	639	if (err)
	640	goto out1;
	641	err = register_filesystem(&minix_fs_type);
	642	if (err)
	643	goto out;
	644	return 0;
	645	out:
	646	destroy_inodecache();
	647	out1:
	648	return err;
	649	}
	650
	651	static void __exit exit_minix_fs(void)
	652	{
	653	unregister_filesystem(&minix_fs_type);
	654	destroy_inodecache();
	655	}
	656
	657	module_init(init_minix_fs)
	658	module_exit(exit_minix_fs)
	659	MODULE_LICENSE("GPL");
	660