2 * linux/fs/sysv/inode.c
5 * Copyright (C) 1991, 1992 Linus Torvalds
8 * Copyright (C) 1992 Doug Evans
11 * Copyright (C) 1993 Pascal Haible, Bruno Haible
14 * Copyright (C) 1993 Paul B. Monday
17 * Copyright (C) 1993 Bruno Haible
18 * Copyright (C) 1997, 1998 Krzysztof G. Baranowski
20 * This file contains code for read/parsing the superblock.
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/buffer_head.h>
30 * The following functions try to recognize specific filesystems.
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.
39 * We discriminate among SystemV4 and SystemV2 FS by the assumption that
40 * the time stamp is not < 01-01-1980.
44 JAN_1_1980
= (10*365 + 2) * 24 * 60 * 60
47 static void detected_xenix(struct sysv_sb_info
*sbi
, unsigned *max_links
)
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
;
55 sbd1
= sbd2
= (struct xenix_super_block
*) bh1
->b_data
;
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);
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
);
78 static void detected_sysv4(struct sysv_sb_info
*sbi
, unsigned *max_links
)
80 struct sysv4_super_block
* sbd
;
81 struct buffer_head
*bh1
= sbi
->s_bh1
;
82 struct buffer_head
*bh2
= sbi
->s_bh2
;
85 sbd
= (struct sysv4_super_block
*) (bh1
->b_data
+ BLOCK_SIZE
/2);
87 sbd
= (struct sysv4_super_block
*) bh2
->b_data
;
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
);
106 static void detected_sysv2(struct sysv_sb_info
*sbi
, unsigned *max_links
)
108 struct sysv2_super_block
*sbd
;
109 struct buffer_head
*bh1
= sbi
->s_bh1
;
110 struct buffer_head
*bh2
= sbi
->s_bh2
;
113 sbd
= (struct sysv2_super_block
*) (bh1
->b_data
+ BLOCK_SIZE
/2);
115 sbd
= (struct sysv2_super_block
*) bh2
->b_data
;
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
);
134 static void detected_coherent(struct sysv_sb_info
*sbi
, unsigned *max_links
)
136 struct coh_super_block
* sbd
;
137 struct buffer_head
*bh1
= sbi
->s_bh1
;
139 sbd
= (struct coh_super_block
*) bh1
->b_data
;
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
);
157 static void detected_v7(struct sysv_sb_info
*sbi
, unsigned *max_links
)
159 struct buffer_head
*bh2
= sbi
->s_bh2
;
160 struct v7_super_block
*sbd
= (struct v7_super_block
*)bh2
->b_data
;
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
);
178 static int detect_xenix(struct sysv_sb_info
*sbi
, struct buffer_head
*bh
)
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
;
187 switch (fs32_to_cpu(sbi
, sbd
->s_type
)) {
189 sbi
->s_type
= FSTYPE_XENIX
;
192 sbi
->s_type
= FSTYPE_XENIX
;
199 static int detect_sysv(struct sysv_sb_info
*sbi
, struct buffer_head
*bh
)
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
;
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
;
214 type
= fs32_to_cpu(sbi
, sbd
->s_type
);
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",
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)
231 sbi
->s_type
= FSTYPE_SYSV2
;
234 if ((type
> 3 || type
< 1) && (type
> 0x30 || type
< 0x10))
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 */
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;
248 sbi
->s_type
= FSTYPE_SYSV4
;
249 return type
>= 0x10 ? type
>> 4 : type
;
252 static int detect_coherent(struct sysv_sb_info
*sbi
, struct buffer_head
*bh
)
254 struct coh_super_block
* sbd
;
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)))
260 sbi
->s_bytesex
= BYTESEX_PDP
;
261 sbi
->s_type
= FSTYPE_COH
;
265 static int detect_sysv_odd(struct sysv_sb_info
*sbi
, struct buffer_head
*bh
)
267 int size
= detect_sysv(sbi
, bh
);
269 return size
>2 ? 0 : size
;
274 int (*test
)(struct sysv_sb_info
*, struct buffer_head
*);
278 {0, detect_coherent
},
279 {9, detect_sysv_odd
},
280 {15,detect_sysv_odd
},
284 static char *flavour_names
[] = {
285 [FSTYPE_XENIX
] = "Xenix",
286 [FSTYPE_SYSV4
] = "SystemV",
287 [FSTYPE_SYSV2
] = "SystemV Release 2",
288 [FSTYPE_COH
] = "Coherent",
290 [FSTYPE_AFS
] = "AFS",
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
,
302 static int complete_read_super(struct super_block
*sb
, int silent
, int size
)
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;
311 sbi
->s_firstinodezone
= 2;
313 flavour_setup
[sbi
->s_type
](sbi
, &sb
->s_max_links
);
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;
324 sbi
->s_ninodes
= (sbi
->s_firstdatazone
- sbi
->s_firstinodezone
)
325 << sbi
->s_inodes_per_block_bits
;
328 printk("VFS: Found a %s FS (block size = %ld) on device %s\n",
329 found
, sb
->s_blocksize
, sb
->s_id
);
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");
341 sb
->s_root
= d_make_root(root_inode
);
343 printk("SysV FS: get root dentry failed\n");
349 static int sysv_fill_super(struct super_block
*sb
, void *data
, int silent
)
351 struct buffer_head
*bh1
, *bh
= NULL
;
352 struct sysv_sb_info
*sbi
;
353 unsigned long blocknr
;
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
));
362 sbi
= kzalloc(sizeof(struct sysv_sb_info
), GFP_KERNEL
);
367 sbi
->s_block_base
= 0;
368 mutex_init(&sbi
->s_lock
);
371 sb_set_blocksize(sb
, BLOCK_SIZE
);
373 for (i
= 0; i
< ARRAY_SIZE(flavours
) && !size
; i
++) {
375 bh
= sb_bread(sb
, flavours
[i
].block
);
378 size
= flavours
[i
].test(SYSV_SB(sb
), bh
);
386 blocknr
= bh
->b_blocknr
<< 1;
388 sb_set_blocksize(sb
, 512);
389 bh1
= sb_bread(sb
, blocknr
);
390 bh
= sb_bread(sb
, blocknr
+ 1);
396 blocknr
= bh
->b_blocknr
>> 1;
398 sb_set_blocksize(sb
, 2048);
399 bh1
= bh
= sb_bread(sb
, blocknr
);
408 if (complete_read_super(sb
, silent
, size
))
414 sb_set_blocksize(sb
, BLOCK_SIZE
);
415 printk("oldfs: cannot read superblock\n");
423 printk("VFS: unable to find oldfs superblock on device %s\n",
429 printk("VFS: oldfs: unsupported block size (%dKb)\n",
434 static int v7_sanity_check(struct super_block
*sb
, struct buffer_head
*bh
)
436 struct v7_super_block
*v7sb
;
437 struct sysv_inode
*v7i
;
438 struct buffer_head
*bh2
;
439 struct sysv_sb_info
*sbi
;
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
)
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);
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
))) {
470 static int v7_fill_super(struct super_block
*sb
, void *data
, int silent
)
472 struct sysv_sb_info
*sbi
;
473 struct buffer_head
*bh
;
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");
480 sbi
= kzalloc(sizeof(struct sysv_sb_info
), GFP_KERNEL
);
485 sbi
->s_block_base
= 0;
486 sbi
->s_type
= FSTYPE_V7
;
487 mutex_init(&sbi
->s_lock
);
490 sb_set_blocksize(sb
, 512);
492 if ((bh
= sb_bread(sb
, 1)) == NULL
) {
494 printk("VFS: unable to read V7 FS superblock on "
495 "device %s.\n", sb
->s_id
);
499 /* Try PDP-11 UNIX */
500 sbi
->s_bytesex
= BYTESEX_PDP
;
501 if (v7_sanity_check(sb
, bh
))
504 /* Try PC/IX, v7/x86 */
505 sbi
->s_bytesex
= BYTESEX_LE
;
506 if (v7_sanity_check(sb
, bh
))
514 if (complete_read_super(sb
, silent
, 1))
518 printk(KERN_ERR
"VFS: could not find a valid V7 on %s.\n",
525 /* Every kernel module contains stuff like this. */
527 static struct dentry
*sysv_mount(struct file_system_type
*fs_type
,
528 int flags
, const char *dev_name
, void *data
)
530 return mount_bdev(fs_type
, flags
, dev_name
, data
, sysv_fill_super
);
533 static struct dentry
*v7_mount(struct file_system_type
*fs_type
,
534 int flags
, const char *dev_name
, void *data
)
536 return mount_bdev(fs_type
, flags
, dev_name
, data
, v7_fill_super
);
539 static struct file_system_type sysv_fs_type
= {
540 .owner
= THIS_MODULE
,
543 .kill_sb
= kill_block_super
,
544 .fs_flags
= FS_REQUIRES_DEV
,
546 MODULE_ALIAS_FS("sysv");
548 static struct file_system_type v7_fs_type
= {
549 .owner
= THIS_MODULE
,
552 .kill_sb
= kill_block_super
,
553 .fs_flags
= FS_REQUIRES_DEV
,
555 MODULE_ALIAS_FS("v7");
558 static int __init
init_sysv_fs(void)
562 error
= sysv_init_icache();
565 error
= register_filesystem(&sysv_fs_type
);
568 error
= register_filesystem(&v7_fs_type
);
574 unregister_filesystem(&sysv_fs_type
);
576 sysv_destroy_icache();
581 static void __exit
exit_sysv_fs(void)
583 unregister_filesystem(&sysv_fs_type
);
584 unregister_filesystem(&v7_fs_type
);
585 sysv_destroy_icache();
588 module_init(init_sysv_fs
)
589 module_exit(exit_sysv_fs
)
590 MODULE_LICENSE("GPL");