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

/*
 *  linux/fs/minix/inode.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  Copyright (C) 1996  Gertjan van Wingerde    ([email protected])
 *	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);

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

	return;
}

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