inode.c 18.2 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
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_final(&inode->i_data);
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)) {
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 = 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

89
static int __init init_inodecache(void)
Linus Torvalds's avatar
Linus Torvalds committed
90 91 92
{
	minix_inode_cachep = kmem_cache_create("minix_inode_cache",
					     sizeof(struct minix_inode_info),
93
					     0, (SLAB_RECLAIM_ACCOUNT|
94
						SLAB_MEM_SPREAD|SLAB_ACCOUNT),
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 104 105 106 107
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
108
	kmem_cache_destroy(minix_inode_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
109 110
}

111
static const struct super_operations minix_sops = {
Linus Torvalds's avatar
Linus Torvalds committed
112 113 114
	.alloc_inode	= minix_alloc_inode,
	.destroy_inode	= minix_destroy_inode,
	.write_inode	= minix_write_inode,
115
	.evict_inode	= minix_evict_inode,
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118 119 120 121 122 123 124 125
	.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;

126
	sync_filesystem(sb);
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130 131 132 133 134
	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. */
135 136
		if (sbi->s_version != MINIX_V3)
			ms->s_state = sbi->s_mount_state;
Linus Torvalds's avatar
Linus Torvalds committed
137 138 139
		mark_buffer_dirty(sbi->s_sbh);
	} else {
	  	/* Mount a partition which is read-only, read-write. */
140 141 142 143 144 145
		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
146 147 148
		mark_buffer_dirty(sbi->s_sbh);

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

169
	sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
170 171 172 173
	if (!sbi)
		return -ENOMEM;
	s->s_fs_info = sbi;

174 175
	BUILD_BUG_ON(32 != sizeof (struct minix_inode));
	BUILD_BUG_ON(64 != sizeof(struct minix2_inode));
Linus Torvalds's avatar
Linus Torvalds committed
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198

	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;
199
		s->s_max_links = MINIX_LINK_MAX;
Linus Torvalds's avatar
Linus Torvalds committed
200 201 202 203
	} else if (s->s_magic == MINIX_SUPER_MAGIC2) {
		sbi->s_version = MINIX_V1;
		sbi->s_dirsize = 32;
		sbi->s_namelen = 30;
204
		s->s_max_links = MINIX_LINK_MAX;
Linus Torvalds's avatar
Linus Torvalds committed
205 206 207 208 209
	} 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;
210
		s->s_max_links = MINIX2_LINK_MAX;
Linus Torvalds's avatar
Linus Torvalds committed
211 212 213 214 215
	} 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;
216
		s->s_max_links = MINIX2_LINK_MAX;
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
	} 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);
232
		s->s_max_links = MINIX2_LINK_MAX;
Linus Torvalds's avatar
Linus Torvalds committed
233 234 235 236 237 238
	} else
		goto out_no_fs;

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

263 264 265 266 267 268 269
	/* 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 "
270
				"imap blocks allocated.  Refusing to mount.\n");
271
		goto out_no_bitmap;
272 273 274
	}

	block = minix_blocks_needed(
275
			(sbi->s_nzones - sbi->s_firstdatazone + 1),
276 277 278 279
			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");
280 281 282 283 284 285 286 287 288
		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;
289 290
	}

291
	ret = -ENOMEM;
292
	s->s_root = d_make_root(root_inode);
293
	if (!s->s_root)
294
		goto out_no_root;
295 296 297 298 299 300 301 302 303 304 305 306 307

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

331 332 333 334 335
out_illegal_sb:
	if (!silent)
		printk("MINIX-fs: bad superblock\n");
	goto out_release;

Linus Torvalds's avatar
Linus Torvalds committed
336 337
out_no_fs:
	if (!silent)
338 339
		printk("VFS: Can't find a Minix filesystem V1 | V2 | V3 "
		       "on device %s.\n", s->s_id);
340
out_release:
Linus Torvalds's avatar
Linus Torvalds committed
341 342 343 344
	brelse(bh);
	goto out;

out_bad_hblock:
345
	printk("MINIX-fs: blocksize too small for device\n");
Linus Torvalds's avatar
Linus Torvalds committed
346 347 348 349
	goto out;

out_bad_sb:
	printk("MINIX-fs: unable to read superblock\n");
350
out:
Linus Torvalds's avatar
Linus Torvalds committed
351 352
	s->s_fs_info = NULL;
	kfree(sbi);
353
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
354 355
}

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

Linus Torvalds's avatar
Linus Torvalds committed
372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
	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);
}
388

Linus Torvalds's avatar
Linus Torvalds committed
389 390 391 392
static int minix_readpage(struct file *file, struct page *page)
{
	return block_read_full_page(page,minix_get_block);
}
393

394
int minix_prepare_chunk(struct page *page, loff_t pos, unsigned len)
Linus Torvalds's avatar
Linus Torvalds committed
395
{
396
	return __block_write_begin(page, pos, len, minix_get_block);
Linus Torvalds's avatar
Linus Torvalds committed
397
}
398

Marco Stornelli's avatar
Marco Stornelli committed
399 400 401 402 403
static void minix_write_failed(struct address_space *mapping, loff_t to)
{
	struct inode *inode = mapping->host;

	if (to > inode->i_size) {
404
		truncate_pagecache(inode, inode->i_size);
Marco Stornelli's avatar
Marco Stornelli committed
405 406 407 408
		minix_truncate(inode);
	}
}

409 410 411 412
static int minix_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
{
413 414 415
	int ret;

	ret = block_write_begin(mapping, pos, len, flags, pagep,
416
				minix_get_block);
Marco Stornelli's avatar
Marco Stornelli committed
417 418
	if (unlikely(ret))
		minix_write_failed(mapping, pos + len);
419 420

	return ret;
421 422
}

Linus Torvalds's avatar
Linus Torvalds committed
423 424 425 426
static sector_t minix_bmap(struct address_space *mapping, sector_t block)
{
	return generic_block_bmap(mapping,block,minix_get_block);
}
427

428
static const struct address_space_operations minix_aops = {
Linus Torvalds's avatar
Linus Torvalds committed
429 430
	.readpage = minix_readpage,
	.writepage = minix_writepage,
431 432
	.write_begin = minix_write_begin,
	.write_end = generic_write_end,
Linus Torvalds's avatar
Linus Torvalds committed
433 434 435
	.bmap = minix_bmap
};

436
static const struct inode_operations minix_symlink_inode_operations = {
437
	.get_link	= page_get_link,
Linus Torvalds's avatar
Linus Torvalds committed
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
	.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;
453
		inode_nohighmem(inode);
Linus Torvalds's avatar
Linus Torvalds committed
454 455 456 457 458 459 460 461
		inode->i_mapping->a_ops = &minix_aops;
	} else
		init_special_inode(inode, inode->i_mode, rdev);
}

/*
 * The minix V1 function to read an inode.
 */
462
static struct inode *V1_minix_iget(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
463 464 465 466 467 468 469 470
{
	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) {
471 472
		iget_failed(inode);
		return ERR_PTR(-EIO);
Linus Torvalds's avatar
Linus Torvalds committed
473 474
	}
	inode->i_mode = raw_inode->i_mode;
475 476
	i_uid_write(inode, raw_inode->i_uid);
	i_gid_write(inode, raw_inode->i_gid);
477
	set_nlink(inode, raw_inode->i_nlinks);
Linus Torvalds's avatar
Linus Torvalds committed
478 479 480 481 482
	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;
483
	inode->i_blocks = 0;
Linus Torvalds's avatar
Linus Torvalds committed
484 485 486 487
	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);
488 489
	unlock_new_inode(inode);
	return inode;
Linus Torvalds's avatar
Linus Torvalds committed
490 491 492 493 494
}

/*
 * The minix V2 function to read an inode.
 */
495
static struct inode *V2_minix_iget(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
496 497 498 499 500 501 502 503
{
	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) {
504 505
		iget_failed(inode);
		return ERR_PTR(-EIO);
Linus Torvalds's avatar
Linus Torvalds committed
506 507
	}
	inode->i_mode = raw_inode->i_mode;
508 509
	i_uid_write(inode, raw_inode->i_uid);
	i_gid_write(inode, raw_inode->i_gid);
510
	set_nlink(inode, raw_inode->i_nlinks);
Linus Torvalds's avatar
Linus Torvalds committed
511 512 513 514 515 516 517
	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;
518
	inode->i_blocks = 0;
Linus Torvalds's avatar
Linus Torvalds committed
519 520 521 522
	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);
523 524
	unlock_new_inode(inode);
	return inode;
Linus Torvalds's avatar
Linus Torvalds committed
525 526 527 528 529
}

/*
 * The global function to read an inode.
 */
530
struct inode *minix_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds's avatar
Linus Torvalds committed
531
{
532 533 534 535 536 537 538 539
	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
540
	if (INODE_VERSION(inode) == MINIX_V1)
541
		return V1_minix_iget(inode);
Linus Torvalds's avatar
Linus Torvalds committed
542
	else
543
		return V2_minix_iget(inode);
Linus Torvalds's avatar
Linus Torvalds committed
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
}

/*
 * 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;
560 561
	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
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586
	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;
587 588
	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
589 590 591 592 593 594 595 596 597 598 599 600 601
	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;
}

602
static int minix_write_inode(struct inode *inode, struct writeback_control *wbc)
Linus Torvalds's avatar
Linus Torvalds committed
603 604 605 606
{
	int err = 0;
	struct buffer_head *bh;

Al Viro's avatar
Al Viro committed
607 608 609 610 611 612
	if (INODE_VERSION(inode) == MINIX_V1)
		bh = V1_minix_update_inode(inode);
	else
		bh = V2_minix_update_inode(inode);
	if (!bh)
		return -EIO;
613
	if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {
Linus Torvalds's avatar
Linus Torvalds committed
614
		sync_dirty_buffer(bh);
Al Viro's avatar
Al Viro committed
615
		if (buffer_req(bh) && !buffer_uptodate(bh)) {
616
			printk("IO error syncing minix inode [%s:%08lx]\n",
Linus Torvalds's avatar
Linus Torvalds committed
617
				inode->i_sb->s_id, inode->i_ino);
Al Viro's avatar
Al Viro committed
618
			err = -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
619 620 621 622 623 624
		}
	}
	brelse (bh);
	return err;
}

625 626
int minix_getattr(const struct path *path, struct kstat *stat,
		  u32 request_mask, unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
627
{
628 629 630 631 632
	struct super_block *sb = path->dentry->d_sb;
	struct inode *inode = d_inode(path->dentry);

	generic_fillattr(inode, stat);
	if (INODE_VERSION(inode) == MINIX_V1)
633
		stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
Linus Torvalds's avatar
Linus Torvalds committed
634
	else
635 636
		stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
	stat->blksize = sb->s_blocksize;
Linus Torvalds's avatar
Linus Torvalds committed
637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
	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
653 654
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
655
{
Al Viro's avatar
Al Viro committed
656
	return mount_bdev(fs_type, flags, dev_name, data, minix_fill_super);
Linus Torvalds's avatar
Linus Torvalds committed
657 658 659 660 661
}

static struct file_system_type minix_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "minix",
Al Viro's avatar
Al Viro committed
662
	.mount		= minix_mount,
Linus Torvalds's avatar
Linus Torvalds committed
663 664 665
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
};
666
MODULE_ALIAS_FS("minix");
Linus Torvalds's avatar
Linus Torvalds committed
667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692

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