2 * linux/fs/adfs/super.c
4 * Copyright (C) 1997-1999 Russell King
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/buffer_head.h>
13 #include <linux/parser.h>
14 #include <linux/mount.h>
15 #include <linux/seq_file.h>
16 #include <linux/statfs.h>
19 #include "dir_fplus.h"
21 #define ADFS_DEFAULT_OWNER_MASK S_IRWXU
22 #define ADFS_DEFAULT_OTHER_MASK (S_IRWXG | S_IRWXO)
24 void __adfs_error(struct super_block
*sb
, const char *function
, const char *fmt
, ...)
30 vsnprintf(error_buf
, sizeof(error_buf
), fmt
, args
);
33 printk(KERN_CRIT
"ADFS-fs error (device %s)%s%s: %s\n",
34 sb
->s_id
, function
? ": " : "",
35 function
? function
: "", error_buf
);
38 static int adfs_checkdiscrecord(struct adfs_discrecord
*dr
)
42 /* sector size must be 256, 512 or 1024 bytes */
43 if (dr
->log2secsize
!= 8 &&
44 dr
->log2secsize
!= 9 &&
45 dr
->log2secsize
!= 10)
48 /* idlen must be at least log2secsize + 3 */
49 if (dr
->idlen
< dr
->log2secsize
+ 3)
52 /* we cannot have such a large disc that we
53 * are unable to represent sector offsets in
54 * 32 bits. This works out at 2.0 TB.
56 if (le32_to_cpu(dr
->disc_size_high
) >> dr
->log2secsize
)
59 /* idlen must be no greater than 19 v2 [1.0] */
63 /* reserved bytes should be zero */
64 for (i
= 0; i
< sizeof(dr
->unused52
); i
++)
65 if (dr
->unused52
[i
] != 0)
71 static unsigned char adfs_calczonecheck(struct super_block
*sb
, unsigned char *map
)
73 unsigned int v0
, v1
, v2
, v3
;
76 v0
= v1
= v2
= v3
= 0;
77 for (i
= sb
->s_blocksize
- 4; i
; i
-= 4) {
78 v0
+= map
[i
] + (v3
>> 8);
80 v1
+= map
[i
+ 1] + (v0
>> 8);
82 v2
+= map
[i
+ 2] + (v1
>> 8);
84 v3
+= map
[i
+ 3] + (v2
>> 8);
88 v1
+= map
[1] + (v0
>> 8);
89 v2
+= map
[2] + (v1
>> 8);
90 v3
+= map
[3] + (v2
>> 8);
92 return v0
^ v1
^ v2
^ v3
;
95 static int adfs_checkmap(struct super_block
*sb
, struct adfs_discmap
*dm
)
97 unsigned char crosscheck
= 0, zonecheck
= 1;
100 for (i
= 0; i
< ADFS_SB(sb
)->s_map_size
; i
++) {
103 map
= dm
[i
].dm_bh
->b_data
;
105 if (adfs_calczonecheck(sb
, map
) != map
[0]) {
106 adfs_error(sb
, "zone %d fails zonecheck", i
);
109 crosscheck
^= map
[3];
111 if (crosscheck
!= 0xff)
112 adfs_error(sb
, "crosscheck != 0xff");
113 return crosscheck
== 0xff && zonecheck
;
116 static void adfs_put_super(struct super_block
*sb
)
119 struct adfs_sb_info
*asb
= ADFS_SB(sb
);
123 for (i
= 0; i
< asb
->s_map_size
; i
++)
124 brelse(asb
->s_map
[i
].dm_bh
);
127 sb
->s_fs_info
= NULL
;
132 static int adfs_show_options(struct seq_file
*seq
, struct vfsmount
*mnt
)
134 struct adfs_sb_info
*asb
= ADFS_SB(mnt
->mnt_sb
);
137 seq_printf(seq
, ",uid=%u", asb
->s_uid
);
139 seq_printf(seq
, ",gid=%u", asb
->s_gid
);
140 if (asb
->s_owner_mask
!= ADFS_DEFAULT_OWNER_MASK
)
141 seq_printf(seq
, ",ownmask=%o", asb
->s_owner_mask
);
142 if (asb
->s_other_mask
!= ADFS_DEFAULT_OTHER_MASK
)
143 seq_printf(seq
, ",othmask=%o", asb
->s_other_mask
);
148 enum {Opt_uid
, Opt_gid
, Opt_ownmask
, Opt_othmask
, Opt_err
};
150 static const match_table_t tokens
= {
153 {Opt_ownmask
, "ownmask=%o"},
154 {Opt_othmask
, "othmask=%o"},
158 static int parse_options(struct super_block
*sb
, char *options
)
161 struct adfs_sb_info
*asb
= ADFS_SB(sb
);
167 while ((p
= strsep(&options
, ",")) != NULL
) {
168 substring_t args
[MAX_OPT_ARGS
];
173 token
= match_token(p
, tokens
, args
);
176 if (match_int(args
, &option
))
181 if (match_int(args
, &option
))
186 if (match_octal(args
, &option
))
188 asb
->s_owner_mask
= option
;
191 if (match_octal(args
, &option
))
193 asb
->s_other_mask
= option
;
196 printk("ADFS-fs: unrecognised mount option \"%s\" "
197 "or missing value\n", p
);
204 static int adfs_remount(struct super_block
*sb
, int *flags
, char *data
)
206 *flags
|= MS_NODIRATIME
;
207 return parse_options(sb
, data
);
210 static int adfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
212 struct super_block
*sb
= dentry
->d_sb
;
213 struct adfs_sb_info
*sbi
= ADFS_SB(sb
);
214 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
216 buf
->f_type
= ADFS_SUPER_MAGIC
;
217 buf
->f_namelen
= sbi
->s_namelen
;
218 buf
->f_bsize
= sb
->s_blocksize
;
219 buf
->f_blocks
= sbi
->s_size
;
220 buf
->f_files
= sbi
->s_ids_per_zone
* sbi
->s_map_size
;
222 buf
->f_bfree
= adfs_map_free(sb
);
223 buf
->f_ffree
= (long)(buf
->f_bfree
* buf
->f_files
) / (long)buf
->f_blocks
;
224 buf
->f_fsid
.val
[0] = (u32
)id
;
225 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
230 static struct kmem_cache
*adfs_inode_cachep
;
232 static struct inode
*adfs_alloc_inode(struct super_block
*sb
)
234 struct adfs_inode_info
*ei
;
235 ei
= (struct adfs_inode_info
*)kmem_cache_alloc(adfs_inode_cachep
, GFP_KERNEL
);
238 return &ei
->vfs_inode
;
241 static void adfs_destroy_inode(struct inode
*inode
)
243 kmem_cache_free(adfs_inode_cachep
, ADFS_I(inode
));
246 static void init_once(void *foo
)
248 struct adfs_inode_info
*ei
= (struct adfs_inode_info
*) foo
;
250 inode_init_once(&ei
->vfs_inode
);
253 static int init_inodecache(void)
255 adfs_inode_cachep
= kmem_cache_create("adfs_inode_cache",
256 sizeof(struct adfs_inode_info
),
257 0, (SLAB_RECLAIM_ACCOUNT
|
260 if (adfs_inode_cachep
== NULL
)
265 static void destroy_inodecache(void)
267 kmem_cache_destroy(adfs_inode_cachep
);
270 static const struct super_operations adfs_sops
= {
271 .alloc_inode
= adfs_alloc_inode
,
272 .destroy_inode
= adfs_destroy_inode
,
273 .write_inode
= adfs_write_inode
,
274 .put_super
= adfs_put_super
,
275 .statfs
= adfs_statfs
,
276 .remount_fs
= adfs_remount
,
277 .show_options
= adfs_show_options
,
280 static struct adfs_discmap
*adfs_read_map(struct super_block
*sb
, struct adfs_discrecord
*dr
)
282 struct adfs_discmap
*dm
;
283 unsigned int map_addr
, zone_size
, nzones
;
285 struct adfs_sb_info
*asb
= ADFS_SB(sb
);
287 nzones
= asb
->s_map_size
;
288 zone_size
= (8 << dr
->log2secsize
) - le16_to_cpu(dr
->zone_spare
);
289 map_addr
= (nzones
>> 1) * zone_size
-
290 ((nzones
> 1) ? ADFS_DR_SIZE_BITS
: 0);
291 map_addr
= signed_asl(map_addr
, asb
->s_map2blk
);
293 asb
->s_ids_per_zone
= zone_size
/ (asb
->s_idlen
+ 1);
295 dm
= kmalloc(nzones
* sizeof(*dm
), GFP_KERNEL
);
297 adfs_error(sb
, "not enough memory");
301 for (zone
= 0; zone
< nzones
; zone
++, map_addr
++) {
302 dm
[zone
].dm_startbit
= 0;
303 dm
[zone
].dm_endbit
= zone_size
;
304 dm
[zone
].dm_startblk
= zone
* zone_size
- ADFS_DR_SIZE_BITS
;
305 dm
[zone
].dm_bh
= sb_bread(sb
, map_addr
);
307 if (!dm
[zone
].dm_bh
) {
308 adfs_error(sb
, "unable to read map");
313 /* adjust the limits for the first and last map zones */
315 dm
[0].dm_startblk
= 0;
316 dm
[0].dm_startbit
= ADFS_DR_SIZE_BITS
;
317 dm
[i
].dm_endbit
= (le32_to_cpu(dr
->disc_size_high
) << (32 - dr
->log2bpmb
)) +
318 (le32_to_cpu(dr
->disc_size
) >> dr
->log2bpmb
) +
319 (ADFS_DR_SIZE_BITS
- i
* zone_size
);
321 if (adfs_checkmap(sb
, dm
))
324 adfs_error(sb
, "map corrupted");
328 brelse(dm
[zone
].dm_bh
);
334 static inline unsigned long adfs_discsize(struct adfs_discrecord
*dr
, int block_bits
)
336 unsigned long discsize
;
338 discsize
= le32_to_cpu(dr
->disc_size_high
) << (32 - block_bits
);
339 discsize
|= le32_to_cpu(dr
->disc_size
) >> block_bits
;
344 static int adfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
346 struct adfs_discrecord
*dr
;
347 struct buffer_head
*bh
;
348 struct object_info root_obj
;
349 unsigned char *b_data
;
350 struct adfs_sb_info
*asb
;
353 sb
->s_flags
|= MS_NODIRATIME
;
355 asb
= kzalloc(sizeof(*asb
), GFP_KERNEL
);
360 /* set default options */
363 asb
->s_owner_mask
= ADFS_DEFAULT_OWNER_MASK
;
364 asb
->s_other_mask
= ADFS_DEFAULT_OTHER_MASK
;
366 if (parse_options(sb
, data
))
369 sb_set_blocksize(sb
, BLOCK_SIZE
);
370 if (!(bh
= sb_bread(sb
, ADFS_DISCRECORD
/ BLOCK_SIZE
))) {
371 adfs_error(sb
, "unable to read superblock");
375 b_data
= bh
->b_data
+ (ADFS_DISCRECORD
% BLOCK_SIZE
);
377 if (adfs_checkbblk(b_data
)) {
379 printk("VFS: Can't find an adfs filesystem on dev "
384 dr
= (struct adfs_discrecord
*)(b_data
+ ADFS_DR_OFFSET
);
387 * Do some sanity checks on the ADFS disc record
389 if (adfs_checkdiscrecord(dr
)) {
391 printk("VPS: Can't find an adfs filesystem on dev "
397 if (sb_set_blocksize(sb
, 1 << dr
->log2secsize
)) {
398 bh
= sb_bread(sb
, ADFS_DISCRECORD
/ sb
->s_blocksize
);
400 adfs_error(sb
, "couldn't read superblock on "
404 b_data
= bh
->b_data
+ (ADFS_DISCRECORD
% sb
->s_blocksize
);
405 if (adfs_checkbblk(b_data
)) {
406 adfs_error(sb
, "disc record mismatch, very weird!");
409 dr
= (struct adfs_discrecord
*)(b_data
+ ADFS_DR_OFFSET
);
412 printk(KERN_ERR
"VFS: Unsupported blocksize on dev "
418 * blocksize on this device should now be set to the ADFS log2secsize
421 sb
->s_magic
= ADFS_SUPER_MAGIC
;
422 asb
->s_idlen
= dr
->idlen
;
423 asb
->s_map_size
= dr
->nzones
| (dr
->nzones_high
<< 8);
424 asb
->s_map2blk
= dr
->log2bpmb
- dr
->log2secsize
;
425 asb
->s_size
= adfs_discsize(dr
, sb
->s_blocksize_bits
);
426 asb
->s_version
= dr
->format_version
;
427 asb
->s_log2sharesize
= dr
->log2sharesize
;
429 asb
->s_map
= adfs_read_map(sb
, dr
);
436 * set up enough so that we can read an inode
438 sb
->s_op
= &adfs_sops
;
440 dr
= (struct adfs_discrecord
*)(asb
->s_map
[0].dm_bh
->b_data
+ 4);
442 root_obj
.parent_id
= root_obj
.file_id
= le32_to_cpu(dr
->root
);
443 root_obj
.name_len
= 0;
444 root_obj
.loadaddr
= 0;
445 root_obj
.execaddr
= 0;
446 root_obj
.size
= ADFS_NEWDIR_SIZE
;
447 root_obj
.attr
= ADFS_NDA_DIRECTORY
| ADFS_NDA_OWNER_READ
|
448 ADFS_NDA_OWNER_WRITE
| ADFS_NDA_PUBLIC_READ
;
451 * If this is a F+ disk with variable length directories,
452 * get the root_size from the disc record.
454 if (asb
->s_version
) {
455 root_obj
.size
= le32_to_cpu(dr
->root_size
);
456 asb
->s_dir
= &adfs_fplus_dir_ops
;
457 asb
->s_namelen
= ADFS_FPLUS_NAME_LEN
;
459 asb
->s_dir
= &adfs_f_dir_ops
;
460 asb
->s_namelen
= ADFS_F_NAME_LEN
;
463 root
= adfs_iget(sb
, &root_obj
);
464 sb
->s_root
= d_alloc_root(root
);
468 for (i
= 0; i
< asb
->s_map_size
; i
++)
469 brelse(asb
->s_map
[i
].dm_bh
);
471 adfs_error(sb
, "get root inode failed\n");
474 sb
->s_root
->d_op
= &adfs_dentry_operations
;
480 sb
->s_fs_info
= NULL
;
485 static int adfs_get_sb(struct file_system_type
*fs_type
,
486 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
488 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, adfs_fill_super
,
492 static struct file_system_type adfs_fs_type
= {
493 .owner
= THIS_MODULE
,
495 .get_sb
= adfs_get_sb
,
496 .kill_sb
= kill_block_super
,
497 .fs_flags
= FS_REQUIRES_DEV
,
500 static int __init
init_adfs_fs(void)
502 int err
= init_inodecache();
505 err
= register_filesystem(&adfs_fs_type
);
510 destroy_inodecache();
515 static void __exit
exit_adfs_fs(void)
517 unregister_filesystem(&adfs_fs_type
);
518 destroy_inodecache();
521 module_init(init_adfs_fs
)
522 module_exit(exit_adfs_fs
)
523 MODULE_LICENSE("GPL");