4 * Copyright (c) 1999 Al Smith
6 * Portions derived from work (c) 1995,1996 Christian Vogelgsang.
9 #include <linux/init.h>
10 #include <linux/module.h>
11 #include <linux/exportfs.h>
12 #include <linux/slab.h>
13 #include <linux/buffer_head.h>
14 #include <linux/vfs.h>
17 #include <linux/efs_vh.h>
18 #include <linux/efs_fs_sb.h>
20 static int efs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
);
21 static int efs_fill_super(struct super_block
*s
, void *d
, int silent
);
23 static struct dentry
*efs_mount(struct file_system_type
*fs_type
,
24 int flags
, const char *dev_name
, void *data
)
26 return mount_bdev(fs_type
, flags
, dev_name
, data
, efs_fill_super
);
29 static struct file_system_type efs_fs_type
= {
33 .kill_sb
= kill_block_super
,
34 .fs_flags
= FS_REQUIRES_DEV
,
37 static struct pt_types sgi_pt_types
[] = {
39 {0x01, "SGI trkrepl"},
40 {0x02, "SGI secrepl"},
43 {SGI_SYSV
, "SGI sysv"},
52 {0x83, "Linux native"},
57 static struct kmem_cache
* efs_inode_cachep
;
59 static struct inode
*efs_alloc_inode(struct super_block
*sb
)
61 struct efs_inode_info
*ei
;
62 ei
= (struct efs_inode_info
*)kmem_cache_alloc(efs_inode_cachep
, GFP_KERNEL
);
65 return &ei
->vfs_inode
;
68 static void efs_i_callback(struct rcu_head
*head
)
70 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
71 kmem_cache_free(efs_inode_cachep
, INODE_INFO(inode
));
74 static void efs_destroy_inode(struct inode
*inode
)
76 call_rcu(&inode
->i_rcu
, efs_i_callback
);
79 static void init_once(void *foo
)
81 struct efs_inode_info
*ei
= (struct efs_inode_info
*) foo
;
83 inode_init_once(&ei
->vfs_inode
);
86 static int init_inodecache(void)
88 efs_inode_cachep
= kmem_cache_create("efs_inode_cache",
89 sizeof(struct efs_inode_info
),
90 0, SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
,
92 if (efs_inode_cachep
== NULL
)
97 static void destroy_inodecache(void)
99 kmem_cache_destroy(efs_inode_cachep
);
102 static void efs_put_super(struct super_block
*s
)
108 static int efs_remount(struct super_block
*sb
, int *flags
, char *data
)
114 static const struct super_operations efs_superblock_operations
= {
115 .alloc_inode
= efs_alloc_inode
,
116 .destroy_inode
= efs_destroy_inode
,
117 .put_super
= efs_put_super
,
118 .statfs
= efs_statfs
,
119 .remount_fs
= efs_remount
,
122 static const struct export_operations efs_export_ops
= {
123 .fh_to_dentry
= efs_fh_to_dentry
,
124 .fh_to_parent
= efs_fh_to_parent
,
125 .get_parent
= efs_get_parent
,
128 static int __init
init_efs_fs(void) {
130 printk("EFS: "EFS_VERSION
" - http://aeschi.ch.eu.org/efs/\n");
131 err
= init_inodecache();
134 err
= register_filesystem(&efs_fs_type
);
139 destroy_inodecache();
144 static void __exit
exit_efs_fs(void) {
145 unregister_filesystem(&efs_fs_type
);
146 destroy_inodecache();
149 module_init(init_efs_fs
)
150 module_exit(exit_efs_fs
)
152 static efs_block_t
efs_validate_vh(struct volume_header
*vh
) {
156 efs_block_t sblock
= 0; /* shuts up gcc */
157 struct pt_types
*pt_entry
;
158 int pt_type
, slice
= -1;
160 if (be32_to_cpu(vh
->vh_magic
) != VHMAGIC
) {
162 * assume that we're dealing with a partition and allow
163 * read_super() to try and detect a valid superblock
169 ui
= ((__be32
*) (vh
+ 1)) - 1;
170 for(csum
= 0; ui
>= ((__be32
*) vh
);) {
172 csum
+= be32_to_cpu(cs
);
175 printk(KERN_INFO
"EFS: SGI disklabel: checksum bad, label corrupted\n");
180 printk(KERN_DEBUG
"EFS: bf: \"%16s\"\n", vh
->vh_bootfile
);
182 for(i
= 0; i
< NVDIR
; i
++) {
184 char name
[VDNAMESIZE
+1];
186 for(j
= 0; j
< VDNAMESIZE
; j
++) {
187 name
[j
] = vh
->vh_vd
[i
].vd_name
[j
];
192 printk(KERN_DEBUG
"EFS: vh: %8s block: 0x%08x size: 0x%08x\n",
194 (int) be32_to_cpu(vh
->vh_vd
[i
].vd_lbn
),
195 (int) be32_to_cpu(vh
->vh_vd
[i
].vd_nbytes
));
200 for(i
= 0; i
< NPARTAB
; i
++) {
201 pt_type
= (int) be32_to_cpu(vh
->vh_pt
[i
].pt_type
);
202 for(pt_entry
= sgi_pt_types
; pt_entry
->pt_name
; pt_entry
++) {
203 if (pt_type
== pt_entry
->pt_type
) break;
206 if (be32_to_cpu(vh
->vh_pt
[i
].pt_nblks
)) {
207 printk(KERN_DEBUG
"EFS: pt %2d: start: %08d size: %08d type: 0x%02x (%s)\n",
209 (int) be32_to_cpu(vh
->vh_pt
[i
].pt_firstlbn
),
210 (int) be32_to_cpu(vh
->vh_pt
[i
].pt_nblks
),
212 (pt_entry
->pt_name
) ? pt_entry
->pt_name
: "unknown");
215 if (IS_EFS(pt_type
)) {
216 sblock
= be32_to_cpu(vh
->vh_pt
[i
].pt_firstlbn
);
222 printk(KERN_NOTICE
"EFS: partition table contained no EFS partitions\n");
225 printk(KERN_INFO
"EFS: using slice %d (type %s, offset 0x%x)\n",
227 (pt_entry
->pt_name
) ? pt_entry
->pt_name
: "unknown",
234 static int efs_validate_super(struct efs_sb_info
*sb
, struct efs_super
*super
) {
236 if (!IS_EFS_MAGIC(be32_to_cpu(super
->fs_magic
)))
239 sb
->fs_magic
= be32_to_cpu(super
->fs_magic
);
240 sb
->total_blocks
= be32_to_cpu(super
->fs_size
);
241 sb
->first_block
= be32_to_cpu(super
->fs_firstcg
);
242 sb
->group_size
= be32_to_cpu(super
->fs_cgfsize
);
243 sb
->data_free
= be32_to_cpu(super
->fs_tfree
);
244 sb
->inode_free
= be32_to_cpu(super
->fs_tinode
);
245 sb
->inode_blocks
= be16_to_cpu(super
->fs_cgisize
);
246 sb
->total_groups
= be16_to_cpu(super
->fs_ncg
);
251 static int efs_fill_super(struct super_block
*s
, void *d
, int silent
)
253 struct efs_sb_info
*sb
;
254 struct buffer_head
*bh
;
258 sb
= kzalloc(sizeof(struct efs_sb_info
), GFP_KERNEL
);
263 s
->s_magic
= EFS_SUPER_MAGIC
;
264 if (!sb_set_blocksize(s
, EFS_BLOCKSIZE
)) {
265 printk(KERN_ERR
"EFS: device does not support %d byte blocks\n",
270 /* read the vh (volume header) block */
274 printk(KERN_ERR
"EFS: cannot read volume header\n");
279 * if this returns zero then we didn't find any partition table.
280 * this isn't (yet) an error - just assume for the moment that
281 * the device is valid and go on to search for a superblock.
283 sb
->fs_start
= efs_validate_vh((struct volume_header
*) bh
->b_data
);
286 if (sb
->fs_start
== -1) {
290 bh
= sb_bread(s
, sb
->fs_start
+ EFS_SUPER
);
292 printk(KERN_ERR
"EFS: cannot read superblock\n");
296 if (efs_validate_super(sb
, (struct efs_super
*) bh
->b_data
)) {
298 printk(KERN_WARNING
"EFS: invalid superblock at block %u\n", sb
->fs_start
+ EFS_SUPER
);
305 if (!(s
->s_flags
& MS_RDONLY
)) {
307 printk(KERN_INFO
"EFS: forcing read-only mode\n");
309 s
->s_flags
|= MS_RDONLY
;
311 s
->s_op
= &efs_superblock_operations
;
312 s
->s_export_op
= &efs_export_ops
;
313 root
= efs_iget(s
, EFS_ROOTINODE
);
315 printk(KERN_ERR
"EFS: get root inode failed\n");
320 s
->s_root
= d_make_root(root
);
322 printk(KERN_ERR
"EFS: get root dentry failed\n");
336 static int efs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
) {
337 struct super_block
*sb
= dentry
->d_sb
;
338 struct efs_sb_info
*sbi
= SUPER_INFO(sb
);
339 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
341 buf
->f_type
= EFS_SUPER_MAGIC
; /* efs magic number */
342 buf
->f_bsize
= EFS_BLOCKSIZE
; /* blocksize */
343 buf
->f_blocks
= sbi
->total_groups
* /* total data blocks */
344 (sbi
->group_size
- sbi
->inode_blocks
);
345 buf
->f_bfree
= sbi
->data_free
; /* free data blocks */
346 buf
->f_bavail
= sbi
->data_free
; /* free blocks for non-root */
347 buf
->f_files
= sbi
->total_groups
* /* total inodes */
349 (EFS_BLOCKSIZE
/ sizeof(struct efs_dinode
));
350 buf
->f_ffree
= sbi
->inode_free
; /* free inodes */
351 buf
->f_fsid
.val
[0] = (u32
)id
;
352 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
353 buf
->f_namelen
= EFS_MAXNAMELEN
; /* max filename length */