inode.c 17.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5
/*
 *  linux/fs/minix/inode.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
6
 *  Copyright (C) 1996  Gertjan van Wingerde
Linus Torvalds's avatar
Linus Torvalds committed
7 8 9
 *	Minix V2 fs support.
 *
 *  Modified for 680x0 by Andreas Schwab
Andries Brouwer's avatar
Andries Brouwer committed
10
 *  Updated to filesystem version 3 by Daniel Aragones
Linus Torvalds's avatar
Linus Torvalds committed
11 12 13 14 15 16 17 18 19
 */

#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>
20
#include <linux/writeback.h>
Linus Torvalds's avatar
Linus Torvalds committed
21

22 23
static int minix_write_inode(struct inode *inode,
		struct writeback_control *wbc);
24
static int minix_statfs(struct dentry *dentry, struct kstatfs *buf);
Linus Torvalds's avatar
Linus Torvalds committed
25 26
static int minix_remount (struct super_block * sb, int * flags, char * data);

27
static void minix_evict_inode(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
28
{
29
	truncate_inode_pages(&inode->i_data, 0);
30 31 32 33 34
	if (!inode->i_nlink) {
		inode->i_size = 0;
		minix_truncate(inode);
	}
	invalidate_inode_buffers(inode);
35
	clear_inode(inode);
36 37
	if (!inode->i_nlink)
		minix_free_inode(inode);
Linus Torvalds's avatar
Linus Torvalds committed
38 39 40 41 42 43 44 45
}

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)) {
Andries Brouwer's avatar
Andries Brouwer committed
46 47
		if (sbi->s_version != MINIX_V3)	 /* s_state is now out from V3 sb */
			sbi->s_ms->s_state = sbi->s_mount_state;
Linus Torvalds's avatar
Linus Torvalds committed
48 49 50 51 52 53 54 55 56 57 58 59
		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);
}

60
static struct kmem_cache * minix_inode_cachep;
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64

static struct inode *minix_alloc_inode(struct super_block *sb)
{
	struct minix_inode_info *ei;
65
	ei = (struct minix_inode_info *)kmem_cache_alloc(minix_inode_cachep, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
66 67 68 69 70
	if (!ei)
		return NULL;
	return &ei->vfs_inode;
}

Nick Piggin's avatar
Nick Piggin committed
71
static void minix_i_callback(struct rcu_head *head)
Linus Torvalds's avatar
Linus Torvalds committed
72
{
Nick Piggin's avatar
Nick Piggin committed
73
	struct inode *inode = container_of(head, struct inode, i_rcu);
Linus Torvalds's avatar
Linus Torvalds committed
74 75 76
	kmem_cache_free(minix_inode_cachep, minix_i(inode));
}

Nick Piggin's avatar
Nick Piggin committed
77 78 79 80 81
static void minix_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, minix_i_callback);
}

82
static void init_once(void *foo)
Linus Torvalds's avatar
Linus Torvalds committed
83 84 85
{
	struct minix_inode_info *ei = (struct minix_inode_info *) foo;

86
	inode_init_once(&ei->vfs_inode);
Linus Torvalds's avatar
Linus Torvalds committed
87
}
88

Linus Torvalds's avatar
Linus Torvalds committed
89 90 91 92
static int init_inodecache(void)
{
	minix_inode_cachep = kmem_cache_create("minix_inode_cache",
					     sizeof(struct minix_inode_info),
93 94
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
95
					     init_once);
Linus Torvalds's avatar
Linus Torvalds committed
96 97 98 99 100 101 102
	if (minix_inode_cachep == NULL)
		return -ENOMEM;
	return 0;
}

static void destroy_inodecache(void)
{
103
	kmem_cache_destroy(minix_inode_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
104 105
}

106
static const struct super_operations minix_sops = {
Linus Torvalds's avatar
Linus Torvalds committed
107 108 109
	.alloc_inode	= minix_alloc_inode,
	.destroy_inode	= minix_destroy_inode,
	.write_inode	= minix_write_inode,
110
	.evict_inode	= minix_evict_inode,
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
	.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. */
Andries Brouwer's avatar
Andries Brouwer committed
129 130
		if (sbi->s_version != MINIX_V3)
			ms->s_state = sbi->s_mount_state;
Linus Torvalds's avatar
Linus Torvalds committed
131 132 133
		mark_buffer_dirty(sbi->s_sbh);
	} else {
	  	/* Mount a partition which is read-only, read-write. */
Andries Brouwer's avatar
Andries Brouwer committed
134 135 136 137 138 139
		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;
		}
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142
		mark_buffer_dirty(sbi->s_sbh);

		if (!(sbi->s_mount_state & MINIX_VALID_FS))
143 144
			printk("MINIX-fs warning: remounting unchecked fs, "
				"running fsck is recommended\n");
Linus Torvalds's avatar
Linus Torvalds committed
145
		else if ((sbi->s_mount_state & MINIX_ERROR_FS))
146 147
			printk("MINIX-fs warning: remounting fs with errors, "
				"running fsck is recommended\n");
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150 151 152 153 154 155 156
	}
	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;
Andries Brouwer's avatar
Andries Brouwer committed
157 158
	struct minix3_super_block *m3s = NULL;
	unsigned long i, block;
Linus Torvalds's avatar
Linus Torvalds committed
159 160
	struct inode *root_inode;
	struct minix_sb_info *sbi;
161
	int ret = -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
162

163
	sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
164 165 166 167
	if (!sbi)
		return -ENOMEM;
	s->s_fs_info = sbi;

168 169
	BUILD_BUG_ON(32 != sizeof (struct minix_inode));
	BUILD_BUG_ON(64 != sizeof(struct minix2_inode));
Linus Torvalds's avatar
Linus Torvalds committed
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192

	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;
193
		s->s_max_links = MINIX_LINK_MAX;
Linus Torvalds's avatar
Linus Torvalds committed
194 195 196 197
	} else if (s->s_magic == MINIX_SUPER_MAGIC2) {
		sbi->s_version = MINIX_V1;
		sbi->s_dirsize = 32;
		sbi->s_namelen = 30;
198
		s->s_max_links = MINIX_LINK_MAX;
Linus Torvalds's avatar
Linus Torvalds committed
199 200 201 202 203
	} 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;
204
		s->s_max_links = MINIX2_LINK_MAX;
Linus Torvalds's avatar
Linus Torvalds committed
205 206 207 208 209
	} 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;
210
		s->s_max_links = MINIX2_LINK_MAX;
Andries Brouwer's avatar
Andries Brouwer committed
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
	} 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_mount_state = MINIX_VALID_FS;
		sb_set_blocksize(s, m3s->s_blocksize);
226
		s->s_max_links = MINIX2_LINK_MAX;
Linus Torvalds's avatar
Linus Torvalds committed
227 228 229 230 231 232
	} else
		goto out_no_fs;

	/*
	 * Allocate the buffer map to keep the superblock small.
	 */
233 234
	if (sbi->s_imap_blocks == 0 || sbi->s_zmap_blocks == 0)
		goto out_illegal_sb;
Linus Torvalds's avatar
Linus Torvalds committed
235
	i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) * sizeof(bh);
236
	map = kzalloc(i, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
	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);

257 258 259 260 261 262 263 264
	/* Apparently minix can create filesystems that allocate more blocks for
	 * the bitmaps than needed.  We simply ignore that, but verify it didn't
	 * create one with not enough blocks and bail out if so.
	 */
	block = minix_blocks_needed(sbi->s_ninodes, s->s_blocksize);
	if (sbi->s_imap_blocks < block) {
		printk("MINIX-fs: file system does not have enough "
				"imap blocks allocated.  Refusing to mount\n");
Al Viro's avatar
Al Viro committed
265
		goto out_no_bitmap;
266 267 268 269 270 271 272 273
	}

	block = minix_blocks_needed(
			(sbi->s_nzones - (sbi->s_firstdatazone + 1)),
			s->s_blocksize);
	if (sbi->s_zmap_blocks < block) {
		printk("MINIX-fs: file system does not have enough "
				"zmap blocks allocated.  Refusing to mount.\n");
Al Viro's avatar
Al Viro committed
274 275 276 277 278 279 280 281 282
		goto out_no_bitmap;
	}

	/* 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;
283 284
	}

285
	ret = -ENOMEM;
Al Viro's avatar
Al Viro committed
286
	s->s_root = d_make_root(root_inode);
287
	if (!s->s_root)
Al Viro's avatar
Al Viro committed
288
		goto out_no_root;
289 290 291 292 293 294 295 296 297 298 299 300 301

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

Linus Torvalds's avatar
Linus Torvalds committed
302 303 304 305 306 307 308 309 310
	return 0;

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");
311
out_freemap:
Linus Torvalds's avatar
Linus Torvalds committed
312 313 314 315 316 317 318 319
	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:
320
	ret = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
321
	if (!silent)
322
		printk("MINIX-fs: can't allocate map\n");
Linus Torvalds's avatar
Linus Torvalds committed
323 324
	goto out_release;

325 326 327 328 329
out_illegal_sb:
	if (!silent)
		printk("MINIX-fs: bad superblock\n");
	goto out_release;

Linus Torvalds's avatar
Linus Torvalds committed
330 331
out_no_fs:
	if (!silent)
Andries Brouwer's avatar
Andries Brouwer committed
332 333
		printk("VFS: Can't find a Minix filesystem V1 | V2 | V3 "
		       "on device %s.\n", s->s_id);
334
out_release:
Linus Torvalds's avatar
Linus Torvalds committed
335 336 337 338
	brelse(bh);
	goto out;

out_bad_hblock:
339
	printk("MINIX-fs: blocksize too small for device\n");
Linus Torvalds's avatar
Linus Torvalds committed
340 341 342 343
	goto out;

out_bad_sb:
	printk("MINIX-fs: unable to read superblock\n");
344
out:
Linus Torvalds's avatar
Linus Torvalds committed
345 346
	s->s_fs_info = NULL;
	kfree(sbi);
347
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
348 349
}

350
static int minix_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds's avatar
Linus Torvalds committed
351
{
352 353 354 355 356
	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;
Linus Torvalds's avatar
Linus Torvalds committed
357
	buf->f_blocks = (sbi->s_nzones - sbi->s_firstdatazone) << sbi->s_log_zone_size;
358
	buf->f_bfree = minix_count_free_blocks(sb);
Linus Torvalds's avatar
Linus Torvalds committed
359 360
	buf->f_bavail = buf->f_bfree;
	buf->f_files = sbi->s_ninodes;
361
	buf->f_ffree = minix_count_free_inodes(sb);
Linus Torvalds's avatar
Linus Torvalds committed
362
	buf->f_namelen = sbi->s_namelen;
363 364 365
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);

Linus Torvalds's avatar
Linus Torvalds committed
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
	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);
}
Nick Piggin's avatar
Nick Piggin committed
382

Linus Torvalds's avatar
Linus Torvalds committed
383 384 385 386
static int minix_readpage(struct file *file, struct page *page)
{
	return block_read_full_page(page,minix_get_block);
}
Nick Piggin's avatar
Nick Piggin committed
387

388
int minix_prepare_chunk(struct page *page, loff_t pos, unsigned len)
Linus Torvalds's avatar
Linus Torvalds committed
389
{
390
	return __block_write_begin(page, pos, len, minix_get_block);
Linus Torvalds's avatar
Linus Torvalds committed
391
}
Nick Piggin's avatar
Nick Piggin committed
392 393 394 395 396

static int minix_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
{
397 398 399
	int ret;

	ret = block_write_begin(mapping, pos, len, flags, pagep,
400
				minix_get_block);
401 402 403 404 405 406 407
	if (unlikely(ret)) {
		loff_t isize = mapping->host->i_size;
		if (pos + len > isize)
			vmtruncate(mapping->host, isize);
	}

	return ret;
Nick Piggin's avatar
Nick Piggin committed
408 409
}

Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413
static sector_t minix_bmap(struct address_space *mapping, sector_t block)
{
	return generic_block_bmap(mapping,block,minix_get_block);
}
Nick Piggin's avatar
Nick Piggin committed
414

415
static const struct address_space_operations minix_aops = {
Linus Torvalds's avatar
Linus Torvalds committed
416 417
	.readpage = minix_readpage,
	.writepage = minix_writepage,
Nick Piggin's avatar
Nick Piggin committed
418 419
	.write_begin = minix_write_begin,
	.write_end = generic_write_end,
Linus Torvalds's avatar
Linus Torvalds committed
420 421 422
	.bmap = minix_bmap
};

423
static const struct inode_operations minix_symlink_inode_operations = {
Linus Torvalds's avatar
Linus Torvalds committed
424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
	.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.
 */
450
static struct inode *V1_minix_iget(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
451 452 453 454 455 456 457 458
{
	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) {
459 460
		iget_failed(inode);
		return ERR_PTR(-EIO);
Linus Torvalds's avatar
Linus Torvalds committed
461 462
	}
	inode->i_mode = raw_inode->i_mode;
463 464
	i_uid_write(inode, raw_inode->i_uid);
	i_gid_write(inode, raw_inode->i_gid);
465
	set_nlink(inode, raw_inode->i_nlinks);
Linus Torvalds's avatar
Linus Torvalds committed
466 467 468 469 470
	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;
471
	inode->i_blocks = 0;
Linus Torvalds's avatar
Linus Torvalds committed
472 473 474 475
	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);
476 477
	unlock_new_inode(inode);
	return inode;
Linus Torvalds's avatar
Linus Torvalds committed
478 479 480 481 482
}

/*
 * The minix V2 function to read an inode.
 */
483
static struct inode *V2_minix_iget(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
484 485 486 487 488 489 490 491
{
	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) {
492 493
		iget_failed(inode);
		return ERR_PTR(-EIO);
Linus Torvalds's avatar
Linus Torvalds committed
494 495
	}
	inode->i_mode = raw_inode->i_mode;
496 497
	i_uid_write(inode, raw_inode->i_uid);
	i_gid_write(inode, raw_inode->i_gid);
498
	set_nlink(inode, raw_inode->i_nlinks);
Linus Torvalds's avatar
Linus Torvalds committed
499 500 501 502 503 504 505
	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;
506
	inode->i_blocks = 0;
Linus Torvalds's avatar
Linus Torvalds committed
507 508 509 510
	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);
511 512
	unlock_new_inode(inode);
	return inode;
Linus Torvalds's avatar
Linus Torvalds committed
513 514 515 516 517
}

/*
 * The global function to read an inode.
 */
518
struct inode *minix_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds's avatar
Linus Torvalds committed
519
{
520 521 522 523 524 525 526 527
	struct inode *inode;

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

Linus Torvalds's avatar
Linus Torvalds committed
528
	if (INODE_VERSION(inode) == MINIX_V1)
529
		return V1_minix_iget(inode);
Linus Torvalds's avatar
Linus Torvalds committed
530
	else
531
		return V2_minix_iget(inode);
Linus Torvalds's avatar
Linus Torvalds committed
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
}

/*
 * 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;
548 549
	raw_inode->i_uid = fs_high2lowuid(i_uid_read(inode));
	raw_inode->i_gid = fs_high2lowgid(i_gid_read(inode));
Linus Torvalds's avatar
Linus Torvalds committed
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
	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;
575 576
	raw_inode->i_uid = fs_high2lowuid(i_uid_read(inode));
	raw_inode->i_gid = fs_high2lowgid(i_gid_read(inode));
Linus Torvalds's avatar
Linus Torvalds committed
577 578 579 580 581 582 583 584 585 586 587 588 589
	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;
}

590
static int minix_write_inode(struct inode *inode, struct writeback_control *wbc)
Linus Torvalds's avatar
Linus Torvalds committed
591 592 593 594
{
	int err = 0;
	struct buffer_head *bh;

Al Viro's avatar
Al Viro committed
595 596 597 598 599 600
	if (INODE_VERSION(inode) == MINIX_V1)
		bh = V1_minix_update_inode(inode);
	else
		bh = V2_minix_update_inode(inode);
	if (!bh)
		return -EIO;
601
	if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {
Linus Torvalds's avatar
Linus Torvalds committed
602
		sync_dirty_buffer(bh);
Al Viro's avatar
Al Viro committed
603
		if (buffer_req(bh) && !buffer_uptodate(bh)) {
604
			printk("IO error syncing minix inode [%s:%08lx]\n",
Linus Torvalds's avatar
Linus Torvalds committed
605
				inode->i_sb->s_id, inode->i_ino);
Al Viro's avatar
Al Viro committed
606
			err = -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
607 608 609 610 611 612 613 614
		}
	}
	brelse (bh);
	return err;
}

int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
615
	struct super_block *sb = dentry->d_sb;
Linus Torvalds's avatar
Linus Torvalds committed
616 617
	generic_fillattr(dentry->d_inode, stat);
	if (INODE_VERSION(dentry->d_inode) == MINIX_V1)
Andries Brouwer's avatar
Andries Brouwer committed
618
		stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
Linus Torvalds's avatar
Linus Torvalds committed
619
	else
Andries Brouwer's avatar
Andries Brouwer committed
620 621
		stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
	stat->blksize = sb->s_blocksize;
Linus Torvalds's avatar
Linus Torvalds committed
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
	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);
}

Al Viro's avatar
Al Viro committed
638 639
static struct dentry *minix_mount(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
640
{
Al Viro's avatar
Al Viro committed
641
	return mount_bdev(fs_type, flags, dev_name, data, minix_fill_super);
Linus Torvalds's avatar
Linus Torvalds committed
642 643 644 645 646
}

static struct file_system_type minix_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "minix",
Al Viro's avatar
Al Viro committed
647
	.mount		= minix_mount,
Linus Torvalds's avatar
Linus Torvalds committed
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
	.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");