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/errno.h>
13 #include <linux/adfs_fs.h>
14 #include <linux/slab.h>
15 #include <linux/time.h>
16 #include <linux/stat.h>
17 #include <linux/string.h>
18 #include <linux/init.h>
19 #include <linux/buffer_head.h>
20 #include <linux/vfs.h>
21 #include <linux/parser.h>
23 #include <asm/bitops.h>
24 #include <asm/uaccess.h>
25 #include <asm/system.h>
31 #include "dir_fplus.h"
33 void __adfs_error(struct super_block
*sb
, const char *function
, const char *fmt
, ...)
39 vsprintf(error_buf
, fmt
, args
);
42 printk(KERN_CRIT
"ADFS-fs error (device %s)%s%s: %s\n",
43 sb
->s_id
, function
? ": " : "",
44 function
? function
: "", error_buf
);
47 static int adfs_checkdiscrecord(struct adfs_discrecord
*dr
)
51 /* sector size must be 256, 512 or 1024 bytes */
52 if (dr
->log2secsize
!= 8 &&
53 dr
->log2secsize
!= 9 &&
54 dr
->log2secsize
!= 10)
57 /* idlen must be at least log2secsize + 3 */
58 if (dr
->idlen
< dr
->log2secsize
+ 3)
61 /* we cannot have such a large disc that we
62 * are unable to represent sector offsets in
63 * 32 bits. This works out at 2.0 TB.
65 if (le32_to_cpu(dr
->disc_size_high
) >> dr
->log2secsize
)
68 /* idlen must be no greater than 19 v2 [1.0] */
72 /* reserved bytes should be zero */
73 for (i
= 0; i
< sizeof(dr
->unused52
); i
++)
74 if (dr
->unused52
[i
] != 0)
80 static unsigned char adfs_calczonecheck(struct super_block
*sb
, unsigned char *map
)
82 unsigned int v0
, v1
, v2
, v3
;
85 v0
= v1
= v2
= v3
= 0;
86 for (i
= sb
->s_blocksize
- 4; i
; i
-= 4) {
87 v0
+= map
[i
] + (v3
>> 8);
89 v1
+= map
[i
+ 1] + (v0
>> 8);
91 v2
+= map
[i
+ 2] + (v1
>> 8);
93 v3
+= map
[i
+ 3] + (v2
>> 8);
97 v1
+= map
[1] + (v0
>> 8);
98 v2
+= map
[2] + (v1
>> 8);
99 v3
+= map
[3] + (v2
>> 8);
101 return v0
^ v1
^ v2
^ v3
;
104 static int adfs_checkmap(struct super_block
*sb
, struct adfs_discmap
*dm
)
106 unsigned char crosscheck
= 0, zonecheck
= 1;
109 for (i
= 0; i
< ADFS_SB(sb
)->s_map_size
; i
++) {
112 map
= dm
[i
].dm_bh
->b_data
;
114 if (adfs_calczonecheck(sb
, map
) != map
[0]) {
115 adfs_error(sb
, "zone %d fails zonecheck", i
);
118 crosscheck
^= map
[3];
120 if (crosscheck
!= 0xff)
121 adfs_error(sb
, "crosscheck != 0xff");
122 return crosscheck
== 0xff && zonecheck
;
125 static void adfs_put_super(struct super_block
*sb
)
128 struct adfs_sb_info
*asb
= ADFS_SB(sb
);
130 for (i
= 0; i
< asb
->s_map_size
; i
++)
131 brelse(asb
->s_map
[i
].dm_bh
);
134 sb
->s_fs_info
= NULL
;
137 enum {Opt_uid
, Opt_gid
, Opt_ownmask
, Opt_othmask
, Opt_err
};
139 static match_table_t tokens
= {
142 {Opt_ownmask
, "ownmask=%o"},
143 {Opt_othmask
, "othmask=%o"},
147 static int parse_options(struct super_block
*sb
, char *options
)
150 struct adfs_sb_info
*asb
= ADFS_SB(sb
);
156 while ((p
= strsep(&options
, ",")) != NULL
) {
157 substring_t args
[MAX_OPT_ARGS
];
162 token
= match_token(p
, tokens
, args
);
165 if (match_int(args
, &option
))
170 if (match_int(args
, &option
))
175 if (match_octal(args
, &option
))
177 asb
->s_owner_mask
= option
;
180 if (match_octal(args
, &option
))
182 asb
->s_other_mask
= option
;
185 printk("ADFS-fs: unrecognised mount option \"%s\" "
186 "or missing value\n", p
);
193 static int adfs_remount(struct super_block
*sb
, int *flags
, char *data
)
195 *flags
|= MS_NODIRATIME
;
196 return parse_options(sb
, data
);
199 static int adfs_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
201 struct adfs_sb_info
*asb
= ADFS_SB(sb
);
203 buf
->f_type
= ADFS_SUPER_MAGIC
;
204 buf
->f_namelen
= asb
->s_namelen
;
205 buf
->f_bsize
= sb
->s_blocksize
;
206 buf
->f_blocks
= asb
->s_size
;
207 buf
->f_files
= asb
->s_ids_per_zone
* asb
->s_map_size
;
209 buf
->f_bfree
= adfs_map_free(sb
);
210 buf
->f_ffree
= (long)(buf
->f_bfree
* buf
->f_files
) / (long)buf
->f_blocks
;
215 static kmem_cache_t
*adfs_inode_cachep
;
217 static struct inode
*adfs_alloc_inode(struct super_block
*sb
)
219 struct adfs_inode_info
*ei
;
220 ei
= (struct adfs_inode_info
*)kmem_cache_alloc(adfs_inode_cachep
, SLAB_KERNEL
);
223 return &ei
->vfs_inode
;
226 static void adfs_destroy_inode(struct inode
*inode
)
228 kmem_cache_free(adfs_inode_cachep
, ADFS_I(inode
));
231 static void init_once(void * foo
, kmem_cache_t
* cachep
, unsigned long flags
)
233 struct adfs_inode_info
*ei
= (struct adfs_inode_info
*) foo
;
235 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
236 SLAB_CTOR_CONSTRUCTOR
)
237 inode_init_once(&ei
->vfs_inode
);
240 static int init_inodecache(void)
242 adfs_inode_cachep
= kmem_cache_create("adfs_inode_cache",
243 sizeof(struct adfs_inode_info
),
244 0, SLAB_RECLAIM_ACCOUNT
,
246 if (adfs_inode_cachep
== NULL
)
251 static void destroy_inodecache(void)
253 if (kmem_cache_destroy(adfs_inode_cachep
))
254 printk(KERN_INFO
"adfs_inode_cache: not all structures were freed\n");
257 static struct super_operations adfs_sops
= {
258 .alloc_inode
= adfs_alloc_inode
,
259 .destroy_inode
= adfs_destroy_inode
,
260 .write_inode
= adfs_write_inode
,
261 .put_super
= adfs_put_super
,
262 .statfs
= adfs_statfs
,
263 .remount_fs
= adfs_remount
,
266 static struct adfs_discmap
*adfs_read_map(struct super_block
*sb
, struct adfs_discrecord
*dr
)
268 struct adfs_discmap
*dm
;
269 unsigned int map_addr
, zone_size
, nzones
;
271 struct adfs_sb_info
*asb
= ADFS_SB(sb
);
273 nzones
= asb
->s_map_size
;
274 zone_size
= (8 << dr
->log2secsize
) - le16_to_cpu(dr
->zone_spare
);
275 map_addr
= (nzones
>> 1) * zone_size
-
276 ((nzones
> 1) ? ADFS_DR_SIZE_BITS
: 0);
277 map_addr
= signed_asl(map_addr
, asb
->s_map2blk
);
279 asb
->s_ids_per_zone
= zone_size
/ (asb
->s_idlen
+ 1);
281 dm
= kmalloc(nzones
* sizeof(*dm
), GFP_KERNEL
);
283 adfs_error(sb
, "not enough memory");
287 for (zone
= 0; zone
< nzones
; zone
++, map_addr
++) {
288 dm
[zone
].dm_startbit
= 0;
289 dm
[zone
].dm_endbit
= zone_size
;
290 dm
[zone
].dm_startblk
= zone
* zone_size
- ADFS_DR_SIZE_BITS
;
291 dm
[zone
].dm_bh
= sb_bread(sb
, map_addr
);
293 if (!dm
[zone
].dm_bh
) {
294 adfs_error(sb
, "unable to read map");
299 /* adjust the limits for the first and last map zones */
301 dm
[0].dm_startblk
= 0;
302 dm
[0].dm_startbit
= ADFS_DR_SIZE_BITS
;
303 dm
[i
].dm_endbit
= (le32_to_cpu(dr
->disc_size_high
) << (32 - dr
->log2bpmb
)) +
304 (le32_to_cpu(dr
->disc_size
) >> dr
->log2bpmb
) +
305 (ADFS_DR_SIZE_BITS
- i
* zone_size
);
307 if (adfs_checkmap(sb
, dm
))
310 adfs_error(sb
, NULL
, "map corrupted");
314 brelse(dm
[zone
].dm_bh
);
320 static inline unsigned long adfs_discsize(struct adfs_discrecord
*dr
, int block_bits
)
322 unsigned long discsize
;
324 discsize
= le32_to_cpu(dr
->disc_size_high
) << (32 - block_bits
);
325 discsize
|= le32_to_cpu(dr
->disc_size
) >> block_bits
;
330 static int adfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
332 struct adfs_discrecord
*dr
;
333 struct buffer_head
*bh
;
334 struct object_info root_obj
;
335 unsigned char *b_data
;
336 struct adfs_sb_info
*asb
;
339 sb
->s_flags
|= MS_NODIRATIME
;
341 asb
= kmalloc(sizeof(*asb
), GFP_KERNEL
);
345 memset(asb
, 0, sizeof(*asb
));
347 /* set default options */
350 asb
->s_owner_mask
= S_IRWXU
;
351 asb
->s_other_mask
= S_IRWXG
| S_IRWXO
;
353 if (parse_options(sb
, data
))
356 sb_set_blocksize(sb
, BLOCK_SIZE
);
357 if (!(bh
= sb_bread(sb
, ADFS_DISCRECORD
/ BLOCK_SIZE
))) {
358 adfs_error(sb
, "unable to read superblock");
362 b_data
= bh
->b_data
+ (ADFS_DISCRECORD
% BLOCK_SIZE
);
364 if (adfs_checkbblk(b_data
)) {
366 printk("VFS: Can't find an adfs filesystem on dev "
371 dr
= (struct adfs_discrecord
*)(b_data
+ ADFS_DR_OFFSET
);
374 * Do some sanity checks on the ADFS disc record
376 if (adfs_checkdiscrecord(dr
)) {
378 printk("VPS: Can't find an adfs filesystem on dev "
384 if (sb_set_blocksize(sb
, 1 << dr
->log2secsize
)) {
385 bh
= sb_bread(sb
, ADFS_DISCRECORD
/ sb
->s_blocksize
);
387 adfs_error(sb
, "couldn't read superblock on "
391 b_data
= bh
->b_data
+ (ADFS_DISCRECORD
% sb
->s_blocksize
);
392 if (adfs_checkbblk(b_data
)) {
393 adfs_error(sb
, "disc record mismatch, very weird!");
396 dr
= (struct adfs_discrecord
*)(b_data
+ ADFS_DR_OFFSET
);
399 printk(KERN_ERR
"VFS: Unsupported blocksize on dev "
405 * blocksize on this device should now be set to the ADFS log2secsize
408 sb
->s_magic
= ADFS_SUPER_MAGIC
;
409 asb
->s_idlen
= dr
->idlen
;
410 asb
->s_map_size
= dr
->nzones
| (dr
->nzones_high
<< 8);
411 asb
->s_map2blk
= dr
->log2bpmb
- dr
->log2secsize
;
412 asb
->s_size
= adfs_discsize(dr
, sb
->s_blocksize_bits
);
413 asb
->s_version
= dr
->format_version
;
414 asb
->s_log2sharesize
= dr
->log2sharesize
;
416 asb
->s_map
= adfs_read_map(sb
, dr
);
423 * set up enough so that we can read an inode
425 sb
->s_op
= &adfs_sops
;
427 dr
= (struct adfs_discrecord
*)(asb
->s_map
[0].dm_bh
->b_data
+ 4);
429 root_obj
.parent_id
= root_obj
.file_id
= le32_to_cpu(dr
->root
);
430 root_obj
.name_len
= 0;
431 root_obj
.loadaddr
= 0;
432 root_obj
.execaddr
= 0;
433 root_obj
.size
= ADFS_NEWDIR_SIZE
;
434 root_obj
.attr
= ADFS_NDA_DIRECTORY
| ADFS_NDA_OWNER_READ
|
435 ADFS_NDA_OWNER_WRITE
| ADFS_NDA_PUBLIC_READ
;
438 * If this is a F+ disk with variable length directories,
439 * get the root_size from the disc record.
441 if (asb
->s_version
) {
442 root_obj
.size
= le32_to_cpu(dr
->root_size
);
443 asb
->s_dir
= &adfs_fplus_dir_ops
;
444 asb
->s_namelen
= ADFS_FPLUS_NAME_LEN
;
446 asb
->s_dir
= &adfs_f_dir_ops
;
447 asb
->s_namelen
= ADFS_F_NAME_LEN
;
450 root
= adfs_iget(sb
, &root_obj
);
451 sb
->s_root
= d_alloc_root(root
);
455 for (i
= 0; i
< asb
->s_map_size
; i
++)
456 brelse(asb
->s_map
[i
].dm_bh
);
458 adfs_error(sb
, "get root inode failed\n");
461 sb
->s_root
->d_op
= &adfs_dentry_operations
;
467 sb
->s_fs_info
= NULL
;
472 static struct super_block
*adfs_get_sb(struct file_system_type
*fs_type
,
473 int flags
, const char *dev_name
, void *data
)
475 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, adfs_fill_super
);
478 static struct file_system_type adfs_fs_type
= {
479 .owner
= THIS_MODULE
,
481 .get_sb
= adfs_get_sb
,
482 .kill_sb
= kill_block_super
,
483 .fs_flags
= FS_REQUIRES_DEV
,
486 static int __init
init_adfs_fs(void)
488 int err
= init_inodecache();
491 err
= register_filesystem(&adfs_fs_type
);
496 destroy_inodecache();
501 static void __exit
exit_adfs_fs(void)
503 unregister_filesystem(&adfs_fs_type
);
504 destroy_inodecache();
507 module_init(init_adfs_fs
)
508 module_exit(exit_adfs_fs
)