xref: /openbmc/linux/fs/sysv/super.c (revision 151f4e2b)
1 /*
2  *  linux/fs/sysv/inode.c
3  *
4  *  minix/inode.c
5  *  Copyright (C) 1991, 1992  Linus Torvalds
6  *
7  *  xenix/inode.c
8  *  Copyright (C) 1992  Doug Evans
9  *
10  *  coh/inode.c
11  *  Copyright (C) 1993  Pascal Haible, Bruno Haible
12  *
13  *  sysv/inode.c
14  *  Copyright (C) 1993  Paul B. Monday
15  *
16  *  sysv/inode.c
17  *  Copyright (C) 1993  Bruno Haible
18  *  Copyright (C) 1997, 1998  Krzysztof G. Baranowski
19  *
20  *  This file contains code for read/parsing the superblock.
21  */
22 
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/buffer_head.h>
27 #include "sysv.h"
28 
29 /*
30  * The following functions try to recognize specific filesystems.
31  *
32  * We recognize:
33  * - Xenix FS by its magic number.
34  * - SystemV FS by its magic number.
35  * - Coherent FS by its funny fname/fpack field.
36  * - SCO AFS by s_nfree == 0xffff
37  * - V7 FS has no distinguishing features.
38  *
39  * We discriminate among SystemV4 and SystemV2 FS by the assumption that
40  * the time stamp is not < 01-01-1980.
41  */
42 
43 enum {
44 	JAN_1_1980 = (10*365 + 2) * 24 * 60 * 60
45 };
46 
47 static void detected_xenix(struct sysv_sb_info *sbi, unsigned *max_links)
48 {
49 	struct buffer_head *bh1 = sbi->s_bh1;
50 	struct buffer_head *bh2 = sbi->s_bh2;
51 	struct xenix_super_block * sbd1;
52 	struct xenix_super_block * sbd2;
53 
54 	if (bh1 != bh2)
55 		sbd1 = sbd2 = (struct xenix_super_block *) bh1->b_data;
56 	else {
57 		/* block size = 512, so bh1 != bh2 */
58 		sbd1 = (struct xenix_super_block *) bh1->b_data;
59 		sbd2 = (struct xenix_super_block *) (bh2->b_data - 512);
60 	}
61 
62 	*max_links = XENIX_LINK_MAX;
63 	sbi->s_fic_size = XENIX_NICINOD;
64 	sbi->s_flc_size = XENIX_NICFREE;
65 	sbi->s_sbd1 = (char *)sbd1;
66 	sbi->s_sbd2 = (char *)sbd2;
67 	sbi->s_sb_fic_count = &sbd1->s_ninode;
68 	sbi->s_sb_fic_inodes = &sbd1->s_inode[0];
69 	sbi->s_sb_total_free_inodes = &sbd2->s_tinode;
70 	sbi->s_bcache_count = &sbd1->s_nfree;
71 	sbi->s_bcache = &sbd1->s_free[0];
72 	sbi->s_free_blocks = &sbd2->s_tfree;
73 	sbi->s_sb_time = &sbd2->s_time;
74 	sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd1->s_isize);
75 	sbi->s_nzones = fs32_to_cpu(sbi, sbd1->s_fsize);
76 }
77 
78 static void detected_sysv4(struct sysv_sb_info *sbi, unsigned *max_links)
79 {
80 	struct sysv4_super_block * sbd;
81 	struct buffer_head *bh1 = sbi->s_bh1;
82 	struct buffer_head *bh2 = sbi->s_bh2;
83 
84 	if (bh1 == bh2)
85 		sbd = (struct sysv4_super_block *) (bh1->b_data + BLOCK_SIZE/2);
86 	else
87 		sbd = (struct sysv4_super_block *) bh2->b_data;
88 
89 	*max_links = SYSV_LINK_MAX;
90 	sbi->s_fic_size = SYSV_NICINOD;
91 	sbi->s_flc_size = SYSV_NICFREE;
92 	sbi->s_sbd1 = (char *)sbd;
93 	sbi->s_sbd2 = (char *)sbd;
94 	sbi->s_sb_fic_count = &sbd->s_ninode;
95 	sbi->s_sb_fic_inodes = &sbd->s_inode[0];
96 	sbi->s_sb_total_free_inodes = &sbd->s_tinode;
97 	sbi->s_bcache_count = &sbd->s_nfree;
98 	sbi->s_bcache = &sbd->s_free[0];
99 	sbi->s_free_blocks = &sbd->s_tfree;
100 	sbi->s_sb_time = &sbd->s_time;
101 	sbi->s_sb_state = &sbd->s_state;
102 	sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
103 	sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
104 }
105 
106 static void detected_sysv2(struct sysv_sb_info *sbi, unsigned *max_links)
107 {
108 	struct sysv2_super_block *sbd;
109 	struct buffer_head *bh1 = sbi->s_bh1;
110 	struct buffer_head *bh2 = sbi->s_bh2;
111 
112 	if (bh1 == bh2)
113 		sbd = (struct sysv2_super_block *) (bh1->b_data + BLOCK_SIZE/2);
114 	else
115 		sbd = (struct sysv2_super_block *) bh2->b_data;
116 
117 	*max_links = SYSV_LINK_MAX;
118 	sbi->s_fic_size = SYSV_NICINOD;
119 	sbi->s_flc_size = SYSV_NICFREE;
120 	sbi->s_sbd1 = (char *)sbd;
121 	sbi->s_sbd2 = (char *)sbd;
122 	sbi->s_sb_fic_count = &sbd->s_ninode;
123 	sbi->s_sb_fic_inodes = &sbd->s_inode[0];
124 	sbi->s_sb_total_free_inodes = &sbd->s_tinode;
125 	sbi->s_bcache_count = &sbd->s_nfree;
126 	sbi->s_bcache = &sbd->s_free[0];
127 	sbi->s_free_blocks = &sbd->s_tfree;
128 	sbi->s_sb_time = &sbd->s_time;
129 	sbi->s_sb_state = &sbd->s_state;
130 	sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
131 	sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
132 }
133 
134 static void detected_coherent(struct sysv_sb_info *sbi, unsigned *max_links)
135 {
136 	struct coh_super_block * sbd;
137 	struct buffer_head *bh1 = sbi->s_bh1;
138 
139 	sbd = (struct coh_super_block *) bh1->b_data;
140 
141 	*max_links = COH_LINK_MAX;
142 	sbi->s_fic_size = COH_NICINOD;
143 	sbi->s_flc_size = COH_NICFREE;
144 	sbi->s_sbd1 = (char *)sbd;
145 	sbi->s_sbd2 = (char *)sbd;
146 	sbi->s_sb_fic_count = &sbd->s_ninode;
147 	sbi->s_sb_fic_inodes = &sbd->s_inode[0];
148 	sbi->s_sb_total_free_inodes = &sbd->s_tinode;
149 	sbi->s_bcache_count = &sbd->s_nfree;
150 	sbi->s_bcache = &sbd->s_free[0];
151 	sbi->s_free_blocks = &sbd->s_tfree;
152 	sbi->s_sb_time = &sbd->s_time;
153 	sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
154 	sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
155 }
156 
157 static void detected_v7(struct sysv_sb_info *sbi, unsigned *max_links)
158 {
159 	struct buffer_head *bh2 = sbi->s_bh2;
160 	struct v7_super_block *sbd = (struct v7_super_block *)bh2->b_data;
161 
162 	*max_links = V7_LINK_MAX;
163 	sbi->s_fic_size = V7_NICINOD;
164 	sbi->s_flc_size = V7_NICFREE;
165 	sbi->s_sbd1 = (char *)sbd;
166 	sbi->s_sbd2 = (char *)sbd;
167 	sbi->s_sb_fic_count = &sbd->s_ninode;
168 	sbi->s_sb_fic_inodes = &sbd->s_inode[0];
169 	sbi->s_sb_total_free_inodes = &sbd->s_tinode;
170 	sbi->s_bcache_count = &sbd->s_nfree;
171 	sbi->s_bcache = &sbd->s_free[0];
172 	sbi->s_free_blocks = &sbd->s_tfree;
173 	sbi->s_sb_time = &sbd->s_time;
174 	sbi->s_firstdatazone = fs16_to_cpu(sbi, sbd->s_isize);
175 	sbi->s_nzones = fs32_to_cpu(sbi, sbd->s_fsize);
176 }
177 
178 static int detect_xenix(struct sysv_sb_info *sbi, struct buffer_head *bh)
179 {
180 	struct xenix_super_block *sbd = (struct xenix_super_block *)bh->b_data;
181 	if (*(__le32 *)&sbd->s_magic == cpu_to_le32(0x2b5544))
182 		sbi->s_bytesex = BYTESEX_LE;
183 	else if (*(__be32 *)&sbd->s_magic == cpu_to_be32(0x2b5544))
184 		sbi->s_bytesex = BYTESEX_BE;
185 	else
186 		return 0;
187 	switch (fs32_to_cpu(sbi, sbd->s_type)) {
188 	case 1:
189 		sbi->s_type = FSTYPE_XENIX;
190 		return 1;
191 	case 2:
192 		sbi->s_type = FSTYPE_XENIX;
193 		return 2;
194 	default:
195 		return 0;
196 	}
197 }
198 
199 static int detect_sysv(struct sysv_sb_info *sbi, struct buffer_head *bh)
200 {
201 	struct super_block *sb = sbi->s_sb;
202 	/* All relevant fields are at the same offsets in R2 and R4 */
203 	struct sysv4_super_block * sbd;
204 	u32 type;
205 
206 	sbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);
207 	if (*(__le32 *)&sbd->s_magic == cpu_to_le32(0xfd187e20))
208 		sbi->s_bytesex = BYTESEX_LE;
209 	else if (*(__be32 *)&sbd->s_magic == cpu_to_be32(0xfd187e20))
210 		sbi->s_bytesex = BYTESEX_BE;
211 	else
212 		return 0;
213 
214 	type = fs32_to_cpu(sbi, sbd->s_type);
215 
216  	if (fs16_to_cpu(sbi, sbd->s_nfree) == 0xffff) {
217  		sbi->s_type = FSTYPE_AFS;
218 		sbi->s_forced_ro = 1;
219  		if (!sb_rdonly(sb)) {
220  			printk("SysV FS: SCO EAFS on %s detected, "
221  				"forcing read-only mode.\n",
222  				sb->s_id);
223  		}
224  		return type;
225  	}
226 
227 	if (fs32_to_cpu(sbi, sbd->s_time) < JAN_1_1980) {
228 		/* this is likely to happen on SystemV2 FS */
229 		if (type > 3 || type < 1)
230 			return 0;
231 		sbi->s_type = FSTYPE_SYSV2;
232 		return type;
233 	}
234 	if ((type > 3 || type < 1) && (type > 0x30 || type < 0x10))
235 		return 0;
236 
237 	/* On Interactive Unix (ISC) Version 4.0/3.x s_type field = 0x10,
238 	   0x20 or 0x30 indicates that symbolic links and the 14-character
239 	   filename limit is gone. Due to lack of information about this
240            feature read-only mode seems to be a reasonable approach... -KGB */
241 
242 	if (type >= 0x10) {
243 		printk("SysV FS: can't handle long file names on %s, "
244 		       "forcing read-only mode.\n", sb->s_id);
245 		sbi->s_forced_ro = 1;
246 	}
247 
248 	sbi->s_type = FSTYPE_SYSV4;
249 	return type >= 0x10 ? type >> 4 : type;
250 }
251 
252 static int detect_coherent(struct sysv_sb_info *sbi, struct buffer_head *bh)
253 {
254 	struct coh_super_block * sbd;
255 
256 	sbd = (struct coh_super_block *) (bh->b_data + BLOCK_SIZE/2);
257 	if ((memcmp(sbd->s_fname,"noname",6) && memcmp(sbd->s_fname,"xxxxx ",6))
258 	    || (memcmp(sbd->s_fpack,"nopack",6) && memcmp(sbd->s_fpack,"xxxxx\n",6)))
259 		return 0;
260 	sbi->s_bytesex = BYTESEX_PDP;
261 	sbi->s_type = FSTYPE_COH;
262 	return 1;
263 }
264 
265 static int detect_sysv_odd(struct sysv_sb_info *sbi, struct buffer_head *bh)
266 {
267 	int size = detect_sysv(sbi, bh);
268 
269 	return size>2 ? 0 : size;
270 }
271 
272 static struct {
273 	int block;
274 	int (*test)(struct sysv_sb_info *, struct buffer_head *);
275 } flavours[] = {
276 	{1, detect_xenix},
277 	{0, detect_sysv},
278 	{0, detect_coherent},
279 	{9, detect_sysv_odd},
280 	{15,detect_sysv_odd},
281 	{18,detect_sysv},
282 };
283 
284 static char *flavour_names[] = {
285 	[FSTYPE_XENIX]	= "Xenix",
286 	[FSTYPE_SYSV4]	= "SystemV",
287 	[FSTYPE_SYSV2]	= "SystemV Release 2",
288 	[FSTYPE_COH]	= "Coherent",
289 	[FSTYPE_V7]	= "V7",
290 	[FSTYPE_AFS]	= "AFS",
291 };
292 
293 static void (*flavour_setup[])(struct sysv_sb_info *, unsigned *) = {
294 	[FSTYPE_XENIX]	= detected_xenix,
295 	[FSTYPE_SYSV4]	= detected_sysv4,
296 	[FSTYPE_SYSV2]	= detected_sysv2,
297 	[FSTYPE_COH]	= detected_coherent,
298 	[FSTYPE_V7]	= detected_v7,
299 	[FSTYPE_AFS]	= detected_sysv4,
300 };
301 
302 static int complete_read_super(struct super_block *sb, int silent, int size)
303 {
304 	struct sysv_sb_info *sbi = SYSV_SB(sb);
305 	struct inode *root_inode;
306 	char *found = flavour_names[sbi->s_type];
307 	u_char n_bits = size+8;
308 	int bsize = 1 << n_bits;
309 	int bsize_4 = bsize >> 2;
310 
311 	sbi->s_firstinodezone = 2;
312 
313 	flavour_setup[sbi->s_type](sbi, &sb->s_max_links);
314 
315 	sbi->s_ndatazones = sbi->s_nzones - sbi->s_firstdatazone;
316 	sbi->s_inodes_per_block = bsize >> 6;
317 	sbi->s_inodes_per_block_1 = (bsize >> 6)-1;
318 	sbi->s_inodes_per_block_bits = n_bits-6;
319 	sbi->s_ind_per_block = bsize_4;
320 	sbi->s_ind_per_block_2 = bsize_4*bsize_4;
321 	sbi->s_toobig_block = 10 + bsize_4 * (1 + bsize_4 * (1 + bsize_4));
322 	sbi->s_ind_per_block_bits = n_bits-2;
323 
324 	sbi->s_ninodes = (sbi->s_firstdatazone - sbi->s_firstinodezone)
325 		<< sbi->s_inodes_per_block_bits;
326 
327 	if (!silent)
328 		printk("VFS: Found a %s FS (block size = %ld) on device %s\n",
329 		       found, sb->s_blocksize, sb->s_id);
330 
331 	sb->s_magic = SYSV_MAGIC_BASE + sbi->s_type;
332 	/* set up enough so that it can read an inode */
333 	sb->s_op = &sysv_sops;
334 	if (sbi->s_forced_ro)
335 		sb->s_flags |= SB_RDONLY;
336 	root_inode = sysv_iget(sb, SYSV_ROOT_INO);
337 	if (IS_ERR(root_inode)) {
338 		printk("SysV FS: get root inode failed\n");
339 		return 0;
340 	}
341 	sb->s_root = d_make_root(root_inode);
342 	if (!sb->s_root) {
343 		printk("SysV FS: get root dentry failed\n");
344 		return 0;
345 	}
346 	return 1;
347 }
348 
349 static int sysv_fill_super(struct super_block *sb, void *data, int silent)
350 {
351 	struct buffer_head *bh1, *bh = NULL;
352 	struct sysv_sb_info *sbi;
353 	unsigned long blocknr;
354 	int size = 0, i;
355 
356 	BUILD_BUG_ON(1024 != sizeof (struct xenix_super_block));
357 	BUILD_BUG_ON(512 != sizeof (struct sysv4_super_block));
358 	BUILD_BUG_ON(512 != sizeof (struct sysv2_super_block));
359 	BUILD_BUG_ON(500 != sizeof (struct coh_super_block));
360 	BUILD_BUG_ON(64 != sizeof (struct sysv_inode));
361 
362 	sbi = kzalloc(sizeof(struct sysv_sb_info), GFP_KERNEL);
363 	if (!sbi)
364 		return -ENOMEM;
365 
366 	sbi->s_sb = sb;
367 	sbi->s_block_base = 0;
368 	mutex_init(&sbi->s_lock);
369 	sb->s_fs_info = sbi;
370 
371 	sb_set_blocksize(sb, BLOCK_SIZE);
372 
373 	for (i = 0; i < ARRAY_SIZE(flavours) && !size; i++) {
374 		brelse(bh);
375 		bh = sb_bread(sb, flavours[i].block);
376 		if (!bh)
377 			continue;
378 		size = flavours[i].test(SYSV_SB(sb), bh);
379 	}
380 
381 	if (!size)
382 		goto Eunknown;
383 
384 	switch (size) {
385 		case 1:
386 			blocknr = bh->b_blocknr << 1;
387 			brelse(bh);
388 			sb_set_blocksize(sb, 512);
389 			bh1 = sb_bread(sb, blocknr);
390 			bh = sb_bread(sb, blocknr + 1);
391 			break;
392 		case 2:
393 			bh1 = bh;
394 			break;
395 		case 3:
396 			blocknr = bh->b_blocknr >> 1;
397 			brelse(bh);
398 			sb_set_blocksize(sb, 2048);
399 			bh1 = bh = sb_bread(sb, blocknr);
400 			break;
401 		default:
402 			goto Ebadsize;
403 	}
404 
405 	if (bh && bh1) {
406 		sbi->s_bh1 = bh1;
407 		sbi->s_bh2 = bh;
408 		if (complete_read_super(sb, silent, size))
409 			return 0;
410 	}
411 
412 	brelse(bh1);
413 	brelse(bh);
414 	sb_set_blocksize(sb, BLOCK_SIZE);
415 	printk("oldfs: cannot read superblock\n");
416 failed:
417 	kfree(sbi);
418 	return -EINVAL;
419 
420 Eunknown:
421 	brelse(bh);
422 	if (!silent)
423 		printk("VFS: unable to find oldfs superblock on device %s\n",
424 			sb->s_id);
425 	goto failed;
426 Ebadsize:
427 	brelse(bh);
428 	if (!silent)
429 		printk("VFS: oldfs: unsupported block size (%dKb)\n",
430 			1<<(size-2));
431 	goto failed;
432 }
433 
434 static int v7_sanity_check(struct super_block *sb, struct buffer_head *bh)
435 {
436 	struct v7_super_block *v7sb;
437 	struct sysv_inode *v7i;
438 	struct buffer_head *bh2;
439 	struct sysv_sb_info *sbi;
440 
441 	sbi = sb->s_fs_info;
442 
443 	/* plausibility check on superblock */
444 	v7sb = (struct v7_super_block *) bh->b_data;
445 	if (fs16_to_cpu(sbi, v7sb->s_nfree) > V7_NICFREE ||
446 	    fs16_to_cpu(sbi, v7sb->s_ninode) > V7_NICINOD ||
447 	    fs32_to_cpu(sbi, v7sb->s_fsize) > V7_MAXSIZE)
448 		return 0;
449 
450 	/* plausibility check on root inode: it is a directory,
451 	   with a nonzero size that is a multiple of 16 */
452 	bh2 = sb_bread(sb, 2);
453 	if (bh2 == NULL)
454 		return 0;
455 
456 	v7i = (struct sysv_inode *)(bh2->b_data + 64);
457 	if ((fs16_to_cpu(sbi, v7i->i_mode) & ~0777) != S_IFDIR ||
458 	    (fs32_to_cpu(sbi, v7i->i_size) == 0) ||
459 	    (fs32_to_cpu(sbi, v7i->i_size) & 017) ||
460 	    (fs32_to_cpu(sbi, v7i->i_size) > V7_NFILES *
461 	     sizeof(struct sysv_dir_entry))) {
462 		brelse(bh2);
463 		return 0;
464 	}
465 
466 	brelse(bh2);
467 	return 1;
468 }
469 
470 static int v7_fill_super(struct super_block *sb, void *data, int silent)
471 {
472 	struct sysv_sb_info *sbi;
473 	struct buffer_head *bh;
474 
475 	if (440 != sizeof (struct v7_super_block))
476 		panic("V7 FS: bad super-block size");
477 	if (64 != sizeof (struct sysv_inode))
478 		panic("sysv fs: bad i-node size");
479 
480 	sbi = kzalloc(sizeof(struct sysv_sb_info), GFP_KERNEL);
481 	if (!sbi)
482 		return -ENOMEM;
483 
484 	sbi->s_sb = sb;
485 	sbi->s_block_base = 0;
486 	sbi->s_type = FSTYPE_V7;
487 	mutex_init(&sbi->s_lock);
488 	sb->s_fs_info = sbi;
489 
490 	sb_set_blocksize(sb, 512);
491 
492 	if ((bh = sb_bread(sb, 1)) == NULL) {
493 		if (!silent)
494 			printk("VFS: unable to read V7 FS superblock on "
495 			       "device %s.\n", sb->s_id);
496 		goto failed;
497 	}
498 
499 	/* Try PDP-11 UNIX */
500 	sbi->s_bytesex = BYTESEX_PDP;
501 	if (v7_sanity_check(sb, bh))
502 		goto detected;
503 
504 	/* Try PC/IX, v7/x86 */
505 	sbi->s_bytesex = BYTESEX_LE;
506 	if (v7_sanity_check(sb, bh))
507 		goto detected;
508 
509 	goto failed;
510 
511 detected:
512 	sbi->s_bh1 = bh;
513 	sbi->s_bh2 = bh;
514 	if (complete_read_super(sb, silent, 1))
515 		return 0;
516 
517 failed:
518 	printk(KERN_ERR "VFS: could not find a valid V7 on %s.\n",
519 		sb->s_id);
520 	brelse(bh);
521 	kfree(sbi);
522 	return -EINVAL;
523 }
524 
525 /* Every kernel module contains stuff like this. */
526 
527 static struct dentry *sysv_mount(struct file_system_type *fs_type,
528 	int flags, const char *dev_name, void *data)
529 {
530 	return mount_bdev(fs_type, flags, dev_name, data, sysv_fill_super);
531 }
532 
533 static struct dentry *v7_mount(struct file_system_type *fs_type,
534 	int flags, const char *dev_name, void *data)
535 {
536 	return mount_bdev(fs_type, flags, dev_name, data, v7_fill_super);
537 }
538 
539 static struct file_system_type sysv_fs_type = {
540 	.owner		= THIS_MODULE,
541 	.name		= "sysv",
542 	.mount		= sysv_mount,
543 	.kill_sb	= kill_block_super,
544 	.fs_flags	= FS_REQUIRES_DEV,
545 };
546 MODULE_ALIAS_FS("sysv");
547 
548 static struct file_system_type v7_fs_type = {
549 	.owner		= THIS_MODULE,
550 	.name		= "v7",
551 	.mount		= v7_mount,
552 	.kill_sb	= kill_block_super,
553 	.fs_flags	= FS_REQUIRES_DEV,
554 };
555 MODULE_ALIAS_FS("v7");
556 MODULE_ALIAS("v7");
557 
558 static int __init init_sysv_fs(void)
559 {
560 	int error;
561 
562 	error = sysv_init_icache();
563 	if (error)
564 		goto out;
565 	error = register_filesystem(&sysv_fs_type);
566 	if (error)
567 		goto destroy_icache;
568 	error = register_filesystem(&v7_fs_type);
569 	if (error)
570 		goto unregister;
571 	return 0;
572 
573 unregister:
574 	unregister_filesystem(&sysv_fs_type);
575 destroy_icache:
576 	sysv_destroy_icache();
577 out:
578 	return error;
579 }
580 
581 static void __exit exit_sysv_fs(void)
582 {
583 	unregister_filesystem(&sysv_fs_type);
584 	unregister_filesystem(&v7_fs_type);
585 	sysv_destroy_icache();
586 }
587 
588 module_init(init_sysv_fs)
589 module_exit(exit_sysv_fs)
590 MODULE_LICENSE("GPL");
591