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