inode.c 18.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 *  linux/fs/minix/inode.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
G
Gertjan van Wingerde 已提交
6
 *  Copyright (C) 1996  Gertjan van Wingerde
L
Linus Torvalds 已提交
7 8 9
 *	Minix V2 fs support.
 *
 *  Modified for 680x0 by Andreas Schwab
A
Andries Brouwer 已提交
10
 *  Updated to filesystem version 3 by Daniel Aragones
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
25 26
static int minix_remount (struct super_block * sb, int * flags, char * data);

27
static void minix_evict_inode(struct inode *inode)
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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)) {
A
Andries Brouwer 已提交
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;
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
61 62 63 64

static struct inode *minix_alloc_inode(struct super_block *sb)
{
	struct minix_inode_info *ei;
F
Firo Yang 已提交
65
	ei = kmem_cache_alloc(minix_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
66 67 68 69 70
	if (!ei)
		return NULL;
	return &ei->vfs_inode;
}

N
Nick Piggin 已提交
71
static void minix_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
72
{
N
Nick Piggin 已提交
73
	struct inode *inode = container_of(head, struct inode, i_rcu);
L
Linus Torvalds 已提交
74 75 76
	kmem_cache_free(minix_inode_cachep, minix_i(inode));
}

N
Nick Piggin 已提交
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)
L
Linus Torvalds 已提交
83 84 85
{
	struct minix_inode_info *ei = (struct minix_inode_info *) foo;

C
Christoph Lameter 已提交
86
	inode_init_once(&ei->vfs_inode);
L
Linus Torvalds 已提交
87
}
88

89
static int __init init_inodecache(void)
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
109 110
}

111
static const struct super_operations minix_sops = {
L
Linus Torvalds 已提交
112 113 114
	.alloc_inode	= minix_alloc_inode,
	.destroy_inode	= minix_destroy_inode,
	.write_inode	= minix_write_inode,
115
	.evict_inode	= minix_evict_inode,
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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. */
A
Andries Brouwer 已提交
135 136
		if (sbi->s_version != MINIX_V3)
			ms->s_state = sbi->s_mount_state;
L
Linus Torvalds 已提交
137 138 139
		mark_buffer_dirty(sbi->s_sbh);
	} else {
	  	/* Mount a partition which is read-only, read-write. */
A
Andries Brouwer 已提交
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;
		}
L
Linus Torvalds 已提交
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");
L
Linus Torvalds 已提交
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");
L
Linus Torvalds 已提交
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;
A
Andries Brouwer 已提交
163 164
	struct minix3_super_block *m3s = NULL;
	unsigned long i, block;
L
Linus Torvalds 已提交
165 166
	struct inode *root_inode;
	struct minix_sb_info *sbi;
167
	int ret = -EINVAL;
L
Linus Torvalds 已提交
168

169
	sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
L
Linus Torvalds 已提交
170 171 172 173
	if (!sbi)
		return -ENOMEM;
	s->s_fs_info = sbi;

A
Alexey Dobriyan 已提交
174 175
	BUILD_BUG_ON(32 != sizeof (struct minix_inode));
	BUILD_BUG_ON(64 != sizeof(struct minix2_inode));
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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;
A
Andries Brouwer 已提交
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;
L
Linus Torvalds 已提交
233 234 235 236 237 238
	} else
		goto out_no_fs;

	/*
	 * Allocate the buffer map to keep the superblock small.
	 */
A
Andries Brouwer 已提交
239 240
	if (sbi->s_imap_blocks == 0 || sbi->s_zmap_blocks == 0)
		goto out_illegal_sb;
L
Linus Torvalds 已提交
241
	i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) * sizeof(bh);
242
	map = kzalloc(i, GFP_KERNEL);
L
Linus Torvalds 已提交
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");
A
Al Viro 已提交
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");
A
Al Viro 已提交
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;
A
Al Viro 已提交
292
	s->s_root = d_make_root(root_inode);
293
	if (!s->s_root)
A
Al Viro 已提交
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");

L
Linus Torvalds 已提交
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");
A
Andries Brouwer 已提交
317
out_freemap:
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
327
	if (!silent)
328
		printk("MINIX-fs: can't allocate map\n");
L
Linus Torvalds 已提交
329 330
	goto out_release;

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

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

out_bad_hblock:
345
	printk("MINIX-fs: blocksize too small for device\n");
L
Linus Torvalds 已提交
346 347 348 349
	goto out;

out_bad_sb:
	printk("MINIX-fs: unable to read superblock\n");
A
Andries Brouwer 已提交
350
out:
L
Linus Torvalds 已提交
351 352
	s->s_fs_info = NULL;
	kfree(sbi);
353
	return ret;
L
Linus Torvalds 已提交
354 355
}

356
static int minix_statfs(struct dentry *dentry, struct kstatfs *buf)
L
Linus Torvalds 已提交
357
{
C
Coly Li 已提交
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;
L
Linus Torvalds 已提交
363
	buf->f_blocks = (sbi->s_nzones - sbi->s_firstdatazone) << sbi->s_log_zone_size;
364
	buf->f_bfree = minix_count_free_blocks(sb);
L
Linus Torvalds 已提交
365 366
	buf->f_bavail = buf->f_bfree;
	buf->f_files = sbi->s_ninodes;
367
	buf->f_ffree = minix_count_free_inodes(sb);
L
Linus Torvalds 已提交
368
	buf->f_namelen = sbi->s_namelen;
C
Coly Li 已提交
369 370 371
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);

L
Linus Torvalds 已提交
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);
}
N
Nick Piggin 已提交
388

L
Linus Torvalds 已提交
389 390 391 392
static int minix_readpage(struct file *file, struct page *page)
{
	return block_read_full_page(page,minix_get_block);
}
N
Nick Piggin 已提交
393

394
int minix_prepare_chunk(struct page *page, loff_t pos, unsigned len)
L
Linus Torvalds 已提交
395
{
396
	return __block_write_begin(page, pos, len, minix_get_block);
L
Linus Torvalds 已提交
397
}
N
Nick Piggin 已提交
398

M
Marco Stornelli 已提交
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);
M
Marco Stornelli 已提交
405 406 407 408
		minix_truncate(inode);
	}
}

N
Nick Piggin 已提交
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);
M
Marco Stornelli 已提交
417 418
	if (unlikely(ret))
		minix_write_failed(mapping, pos + len);
419 420

	return ret;
N
Nick Piggin 已提交
421 422
}

L
Linus Torvalds 已提交
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);
}
N
Nick Piggin 已提交
427

428
static const struct address_space_operations minix_aops = {
L
Linus Torvalds 已提交
429 430
	.readpage = minix_readpage,
	.writepage = minix_writepage,
N
Nick Piggin 已提交
431 432
	.write_begin = minix_write_begin,
	.write_end = generic_write_end,
L
Linus Torvalds 已提交
433 434 435
	.bmap = minix_bmap
};

436
static const struct inode_operations minix_symlink_inode_operations = {
437
	.get_link	= page_get_link,
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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)
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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);
M
Miklos Szeredi 已提交
477
	set_nlink(inode, raw_inode->i_nlinks);
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
490 491 492 493 494
}

/*
 * The minix V2 function to read an inode.
 */
495
static struct inode *V2_minix_iget(struct inode *inode)
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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);
M
Miklos Szeredi 已提交
510
	set_nlink(inode, raw_inode->i_nlinks);
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
525 526 527 528 529
}

/*
 * The global function to read an inode.
 */
530
struct inode *minix_iget(struct super_block *sb, unsigned long ino)
L
Linus Torvalds 已提交
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;

L
Linus Torvalds 已提交
540
	if (INODE_VERSION(inode) == MINIX_V1)
541
		return V1_minix_iget(inode);
L
Linus Torvalds 已提交
542
	else
543
		return V2_minix_iget(inode);
L
Linus Torvalds 已提交
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));
L
Linus Torvalds 已提交
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));
L
Linus Torvalds 已提交
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)
L
Linus Torvalds 已提交
603 604 605 606
{
	int err = 0;
	struct buffer_head *bh;

A
Al Viro 已提交
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)) {
L
Linus Torvalds 已提交
614
		sync_dirty_buffer(bh);
A
Al Viro 已提交
615
		if (buffer_req(bh) && !buffer_uptodate(bh)) {
616
			printk("IO error syncing minix inode [%s:%08lx]\n",
L
Linus Torvalds 已提交
617
				inode->i_sb->s_id, inode->i_ino);
A
Al Viro 已提交
618
			err = -EIO;
L
Linus Torvalds 已提交
619 620 621 622 623 624 625 626
		}
	}
	brelse (bh);
	return err;
}

int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
627
	struct super_block *sb = dentry->d_sb;
628 629
	generic_fillattr(d_inode(dentry), stat);
	if (INODE_VERSION(d_inode(dentry)) == MINIX_V1)
A
Andries Brouwer 已提交
630
		stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
L
Linus Torvalds 已提交
631
	else
A
Andries Brouwer 已提交
632 633
		stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
	stat->blksize = sb->s_blocksize;
L
Linus Torvalds 已提交
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
	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);
}

A
Al Viro 已提交
650 651
static struct dentry *minix_mount(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data)
L
Linus Torvalds 已提交
652
{
A
Al Viro 已提交
653
	return mount_bdev(fs_type, flags, dev_name, data, minix_fill_super);
L
Linus Torvalds 已提交
654 655 656 657 658
}

static struct file_system_type minix_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "minix",
A
Al Viro 已提交
659
	.mount		= minix_mount,
L
Linus Torvalds 已提交
660 661 662
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
};
663
MODULE_ALIAS_FS("minix");
L
Linus Torvalds 已提交
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689

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