[linux.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);

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

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 int minix_write_inode(struct inode *inode, int wait)
{
	int err = 0;
	struct buffer_head *bh;

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