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/slab.h>
17 #include <linux/statfs.h>
18 #include <linux/user_namespace.h>
21 #include "dir_fplus.h"
23 #define ADFS_DEFAULT_OWNER_MASK S_IRWXU
24 #define ADFS_DEFAULT_OTHER_MASK (S_IRWXG | S_IRWXO)
26 void __adfs_error(struct super_block
*sb
, const char *function
, const char *fmt
, ...)
32 vsnprintf(error_buf
, sizeof(error_buf
), fmt
, args
);
35 printk(KERN_CRIT
"ADFS-fs error (device %s)%s%s: %s\n",
36 sb
->s_id
, function
? ": " : "",
37 function
? function
: "", error_buf
);
40 static int adfs_checkdiscrecord(struct adfs_discrecord
*dr
)
44 /* sector size must be 256, 512 or 1024 bytes */
45 if (dr
->log2secsize
!= 8 &&
46 dr
->log2secsize
!= 9 &&
47 dr
->log2secsize
!= 10)
50 /* idlen must be at least log2secsize + 3 */
51 if (dr
->idlen
< dr
->log2secsize
+ 3)
54 /* we cannot have such a large disc that we
55 * are unable to represent sector offsets in
56 * 32 bits. This works out at 2.0 TB.
58 if (le32_to_cpu(dr
->disc_size_high
) >> dr
->log2secsize
)
61 /* idlen must be no greater than 19 v2 [1.0] */
65 /* reserved bytes should be zero */
66 for (i
= 0; i
< sizeof(dr
->unused52
); i
++)
67 if (dr
->unused52
[i
] != 0)
73 static unsigned char adfs_calczonecheck(struct super_block
*sb
, unsigned char *map
)
75 unsigned int v0
, v1
, v2
, v3
;
78 v0
= v1
= v2
= v3
= 0;
79 for (i
= sb
->s_blocksize
- 4; i
; i
-= 4) {
80 v0
+= map
[i
] + (v3
>> 8);
82 v1
+= map
[i
+ 1] + (v0
>> 8);
84 v2
+= map
[i
+ 2] + (v1
>> 8);
86 v3
+= map
[i
+ 3] + (v2
>> 8);
90 v1
+= map
[1] + (v0
>> 8);
91 v2
+= map
[2] + (v1
>> 8);
92 v3
+= map
[3] + (v2
>> 8);
94 return v0
^ v1
^ v2
^ v3
;
97 static int adfs_checkmap(struct super_block
*sb
, struct adfs_discmap
*dm
)
99 unsigned char crosscheck
= 0, zonecheck
= 1;
102 for (i
= 0; i
< ADFS_SB(sb
)->s_map_size
; i
++) {
105 map
= dm
[i
].dm_bh
->b_data
;
107 if (adfs_calczonecheck(sb
, map
) != map
[0]) {
108 adfs_error(sb
, "zone %d fails zonecheck", i
);
111 crosscheck
^= map
[3];
113 if (crosscheck
!= 0xff)
114 adfs_error(sb
, "crosscheck != 0xff");
115 return crosscheck
== 0xff && zonecheck
;
118 static void adfs_put_super(struct super_block
*sb
)
121 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
);
129 static int adfs_show_options(struct seq_file
*seq
, struct dentry
*root
)
131 struct adfs_sb_info
*asb
= ADFS_SB(root
->d_sb
);
133 if (!uid_eq(asb
->s_uid
, GLOBAL_ROOT_UID
))
134 seq_printf(seq
, ",uid=%u", from_kuid_munged(&init_user_ns
, asb
->s_uid
));
135 if (!gid_eq(asb
->s_gid
, GLOBAL_ROOT_GID
))
136 seq_printf(seq
, ",gid=%u", from_kgid_munged(&init_user_ns
, asb
->s_gid
));
137 if (asb
->s_owner_mask
!= ADFS_DEFAULT_OWNER_MASK
)
138 seq_printf(seq
, ",ownmask=%o", asb
->s_owner_mask
);
139 if (asb
->s_other_mask
!= ADFS_DEFAULT_OTHER_MASK
)
140 seq_printf(seq
, ",othmask=%o", asb
->s_other_mask
);
141 if (asb
->s_ftsuffix
!= 0)
142 seq_printf(seq
, ",ftsuffix=%u", asb
->s_ftsuffix
);
147 enum {Opt_uid
, Opt_gid
, Opt_ownmask
, Opt_othmask
, Opt_ftsuffix
, Opt_err
};
149 static const match_table_t tokens
= {
152 {Opt_ownmask
, "ownmask=%o"},
153 {Opt_othmask
, "othmask=%o"},
154 {Opt_ftsuffix
, "ftsuffix=%u"},
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
))
178 asb
->s_uid
= make_kuid(current_user_ns(), option
);
179 if (!uid_valid(asb
->s_uid
))
183 if (match_int(args
, &option
))
185 asb
->s_gid
= make_kgid(current_user_ns(), option
);
186 if (!gid_valid(asb
->s_gid
))
190 if (match_octal(args
, &option
))
192 asb
->s_owner_mask
= option
;
195 if (match_octal(args
, &option
))
197 asb
->s_other_mask
= option
;
200 if (match_int(args
, &option
))
202 asb
->s_ftsuffix
= option
;
205 printk("ADFS-fs: unrecognised mount option \"%s\" "
206 "or missing value\n", p
);
213 static int adfs_remount(struct super_block
*sb
, int *flags
, char *data
)
215 *flags
|= MS_NODIRATIME
;
216 return parse_options(sb
, data
);
219 static int adfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
221 struct super_block
*sb
= dentry
->d_sb
;
222 struct adfs_sb_info
*sbi
= ADFS_SB(sb
);
223 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
225 buf
->f_type
= ADFS_SUPER_MAGIC
;
226 buf
->f_namelen
= sbi
->s_namelen
;
227 buf
->f_bsize
= sb
->s_blocksize
;
228 buf
->f_blocks
= sbi
->s_size
;
229 buf
->f_files
= sbi
->s_ids_per_zone
* sbi
->s_map_size
;
231 buf
->f_bfree
= adfs_map_free(sb
);
232 buf
->f_ffree
= (long)(buf
->f_bfree
* buf
->f_files
) / (long)buf
->f_blocks
;
233 buf
->f_fsid
.val
[0] = (u32
)id
;
234 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
239 static struct kmem_cache
*adfs_inode_cachep
;
241 static struct inode
*adfs_alloc_inode(struct super_block
*sb
)
243 struct adfs_inode_info
*ei
;
244 ei
= (struct adfs_inode_info
*)kmem_cache_alloc(adfs_inode_cachep
, GFP_KERNEL
);
247 return &ei
->vfs_inode
;
250 static void adfs_i_callback(struct rcu_head
*head
)
252 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
253 kmem_cache_free(adfs_inode_cachep
, ADFS_I(inode
));
256 static void adfs_destroy_inode(struct inode
*inode
)
258 call_rcu(&inode
->i_rcu
, adfs_i_callback
);
261 static void init_once(void *foo
)
263 struct adfs_inode_info
*ei
= (struct adfs_inode_info
*) foo
;
265 inode_init_once(&ei
->vfs_inode
);
268 static int init_inodecache(void)
270 adfs_inode_cachep
= kmem_cache_create("adfs_inode_cache",
271 sizeof(struct adfs_inode_info
),
272 0, (SLAB_RECLAIM_ACCOUNT
|
275 if (adfs_inode_cachep
== NULL
)
280 static void destroy_inodecache(void)
283 * Make sure all delayed rcu free inodes are flushed before we
287 kmem_cache_destroy(adfs_inode_cachep
);
290 static const struct super_operations adfs_sops
= {
291 .alloc_inode
= adfs_alloc_inode
,
292 .destroy_inode
= adfs_destroy_inode
,
293 .write_inode
= adfs_write_inode
,
294 .put_super
= adfs_put_super
,
295 .statfs
= adfs_statfs
,
296 .remount_fs
= adfs_remount
,
297 .show_options
= adfs_show_options
,
300 static struct adfs_discmap
*adfs_read_map(struct super_block
*sb
, struct adfs_discrecord
*dr
)
302 struct adfs_discmap
*dm
;
303 unsigned int map_addr
, zone_size
, nzones
;
305 struct adfs_sb_info
*asb
= ADFS_SB(sb
);
307 nzones
= asb
->s_map_size
;
308 zone_size
= (8 << dr
->log2secsize
) - le16_to_cpu(dr
->zone_spare
);
309 map_addr
= (nzones
>> 1) * zone_size
-
310 ((nzones
> 1) ? ADFS_DR_SIZE_BITS
: 0);
311 map_addr
= signed_asl(map_addr
, asb
->s_map2blk
);
313 asb
->s_ids_per_zone
= zone_size
/ (asb
->s_idlen
+ 1);
315 dm
= kmalloc(nzones
* sizeof(*dm
), GFP_KERNEL
);
317 adfs_error(sb
, "not enough memory");
321 for (zone
= 0; zone
< nzones
; zone
++, map_addr
++) {
322 dm
[zone
].dm_startbit
= 0;
323 dm
[zone
].dm_endbit
= zone_size
;
324 dm
[zone
].dm_startblk
= zone
* zone_size
- ADFS_DR_SIZE_BITS
;
325 dm
[zone
].dm_bh
= sb_bread(sb
, map_addr
);
327 if (!dm
[zone
].dm_bh
) {
328 adfs_error(sb
, "unable to read map");
333 /* adjust the limits for the first and last map zones */
335 dm
[0].dm_startblk
= 0;
336 dm
[0].dm_startbit
= ADFS_DR_SIZE_BITS
;
337 dm
[i
].dm_endbit
= (le32_to_cpu(dr
->disc_size_high
) << (32 - dr
->log2bpmb
)) +
338 (le32_to_cpu(dr
->disc_size
) >> dr
->log2bpmb
) +
339 (ADFS_DR_SIZE_BITS
- i
* zone_size
);
341 if (adfs_checkmap(sb
, dm
))
344 adfs_error(sb
, "map corrupted");
348 brelse(dm
[zone
].dm_bh
);
354 static inline unsigned long adfs_discsize(struct adfs_discrecord
*dr
, int block_bits
)
356 unsigned long discsize
;
358 discsize
= le32_to_cpu(dr
->disc_size_high
) << (32 - block_bits
);
359 discsize
|= le32_to_cpu(dr
->disc_size
) >> block_bits
;
364 static int adfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
366 struct adfs_discrecord
*dr
;
367 struct buffer_head
*bh
;
368 struct object_info root_obj
;
369 unsigned char *b_data
;
370 struct adfs_sb_info
*asb
;
373 sb
->s_flags
|= MS_NODIRATIME
;
375 asb
= kzalloc(sizeof(*asb
), GFP_KERNEL
);
380 /* set default options */
381 asb
->s_uid
= GLOBAL_ROOT_UID
;
382 asb
->s_gid
= GLOBAL_ROOT_GID
;
383 asb
->s_owner_mask
= ADFS_DEFAULT_OWNER_MASK
;
384 asb
->s_other_mask
= ADFS_DEFAULT_OTHER_MASK
;
387 if (parse_options(sb
, data
))
390 sb_set_blocksize(sb
, BLOCK_SIZE
);
391 if (!(bh
= sb_bread(sb
, ADFS_DISCRECORD
/ BLOCK_SIZE
))) {
392 adfs_error(sb
, "unable to read superblock");
396 b_data
= bh
->b_data
+ (ADFS_DISCRECORD
% BLOCK_SIZE
);
398 if (adfs_checkbblk(b_data
)) {
400 printk("VFS: Can't find an adfs filesystem on dev "
405 dr
= (struct adfs_discrecord
*)(b_data
+ ADFS_DR_OFFSET
);
408 * Do some sanity checks on the ADFS disc record
410 if (adfs_checkdiscrecord(dr
)) {
412 printk("VPS: Can't find an adfs filesystem on dev "
418 if (sb_set_blocksize(sb
, 1 << dr
->log2secsize
)) {
419 bh
= sb_bread(sb
, ADFS_DISCRECORD
/ sb
->s_blocksize
);
421 adfs_error(sb
, "couldn't read superblock on "
425 b_data
= bh
->b_data
+ (ADFS_DISCRECORD
% sb
->s_blocksize
);
426 if (adfs_checkbblk(b_data
)) {
427 adfs_error(sb
, "disc record mismatch, very weird!");
430 dr
= (struct adfs_discrecord
*)(b_data
+ ADFS_DR_OFFSET
);
433 printk(KERN_ERR
"VFS: Unsupported blocksize on dev "
439 * blocksize on this device should now be set to the ADFS log2secsize
442 sb
->s_magic
= ADFS_SUPER_MAGIC
;
443 asb
->s_idlen
= dr
->idlen
;
444 asb
->s_map_size
= dr
->nzones
| (dr
->nzones_high
<< 8);
445 asb
->s_map2blk
= dr
->log2bpmb
- dr
->log2secsize
;
446 asb
->s_size
= adfs_discsize(dr
, sb
->s_blocksize_bits
);
447 asb
->s_version
= dr
->format_version
;
448 asb
->s_log2sharesize
= dr
->log2sharesize
;
450 asb
->s_map
= adfs_read_map(sb
, dr
);
457 * set up enough so that we can read an inode
459 sb
->s_op
= &adfs_sops
;
461 dr
= (struct adfs_discrecord
*)(asb
->s_map
[0].dm_bh
->b_data
+ 4);
463 root_obj
.parent_id
= root_obj
.file_id
= le32_to_cpu(dr
->root
);
464 root_obj
.name_len
= 0;
465 /* Set root object date as 01 Jan 1987 00:00:00 */
466 root_obj
.loadaddr
= 0xfff0003f;
467 root_obj
.execaddr
= 0xec22c000;
468 root_obj
.size
= ADFS_NEWDIR_SIZE
;
469 root_obj
.attr
= ADFS_NDA_DIRECTORY
| ADFS_NDA_OWNER_READ
|
470 ADFS_NDA_OWNER_WRITE
| ADFS_NDA_PUBLIC_READ
;
471 root_obj
.filetype
= -1;
474 * If this is a F+ disk with variable length directories,
475 * get the root_size from the disc record.
477 if (asb
->s_version
) {
478 root_obj
.size
= le32_to_cpu(dr
->root_size
);
479 asb
->s_dir
= &adfs_fplus_dir_ops
;
480 asb
->s_namelen
= ADFS_FPLUS_NAME_LEN
;
482 asb
->s_dir
= &adfs_f_dir_ops
;
483 asb
->s_namelen
= ADFS_F_NAME_LEN
;
486 * ,xyz hex filetype suffix may be added by driver
487 * to files that have valid RISC OS filetype
492 sb
->s_d_op
= &adfs_dentry_operations
;
493 root
= adfs_iget(sb
, &root_obj
);
494 sb
->s_root
= d_make_root(root
);
497 for (i
= 0; i
< asb
->s_map_size
; i
++)
498 brelse(asb
->s_map
[i
].dm_bh
);
500 adfs_error(sb
, "get root inode failed\n");
508 sb
->s_fs_info
= NULL
;
513 static struct dentry
*adfs_mount(struct file_system_type
*fs_type
,
514 int flags
, const char *dev_name
, void *data
)
516 return mount_bdev(fs_type
, flags
, dev_name
, data
, adfs_fill_super
);
519 static struct file_system_type adfs_fs_type
= {
520 .owner
= THIS_MODULE
,
523 .kill_sb
= kill_block_super
,
524 .fs_flags
= FS_REQUIRES_DEV
,
526 MODULE_ALIAS_FS("adfs");
528 static int __init
init_adfs_fs(void)
530 int err
= init_inodecache();
533 err
= register_filesystem(&adfs_fs_type
);
538 destroy_inodecache();
543 static void __exit
exit_adfs_fs(void)
545 unregister_filesystem(&adfs_fs_type
);
546 destroy_inodecache();
549 module_init(init_adfs_fs
)
550 module_exit(exit_adfs_fs
)
551 MODULE_LICENSE("GPL");