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/efs_fs.h>
12 #include <linux/efs_vh.h>
13 #include <linux/efs_fs_sb.h>
14 #include <linux/slab.h>
15 #include <linux/buffer_head.h>
16 #include <linux/vfs.h>
18 static int efs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
);
19 static int efs_fill_super(struct super_block
*s
, void *d
, int silent
);
21 static int efs_get_sb(struct file_system_type
*fs_type
,
22 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
24 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, efs_fill_super
, mnt
);
27 static struct file_system_type efs_fs_type
= {
31 .kill_sb
= kill_block_super
,
32 .fs_flags
= FS_REQUIRES_DEV
,
35 static struct pt_types sgi_pt_types
[] = {
37 {0x01, "SGI trkrepl"},
38 {0x02, "SGI secrepl"},
41 {SGI_SYSV
, "SGI sysv"},
50 {0x83, "Linux native"},
55 static struct kmem_cache
* efs_inode_cachep
;
57 static struct inode
*efs_alloc_inode(struct super_block
*sb
)
59 struct efs_inode_info
*ei
;
60 ei
= (struct efs_inode_info
*)kmem_cache_alloc(efs_inode_cachep
, GFP_KERNEL
);
63 return &ei
->vfs_inode
;
66 static void efs_destroy_inode(struct inode
*inode
)
68 kmem_cache_free(efs_inode_cachep
, INODE_INFO(inode
));
71 static void init_once(void * foo
, struct kmem_cache
* cachep
, unsigned long flags
)
73 struct efs_inode_info
*ei
= (struct efs_inode_info
*) foo
;
75 if (flags
& SLAB_CTOR_CONSTRUCTOR
)
76 inode_init_once(&ei
->vfs_inode
);
79 static int init_inodecache(void)
81 efs_inode_cachep
= kmem_cache_create("efs_inode_cache",
82 sizeof(struct efs_inode_info
),
83 0, SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
,
85 if (efs_inode_cachep
== NULL
)
90 static void destroy_inodecache(void)
92 kmem_cache_destroy(efs_inode_cachep
);
95 static void efs_put_super(struct super_block
*s
)
101 static int efs_remount(struct super_block
*sb
, int *flags
, char *data
)
107 static const struct super_operations efs_superblock_operations
= {
108 .alloc_inode
= efs_alloc_inode
,
109 .destroy_inode
= efs_destroy_inode
,
110 .read_inode
= efs_read_inode
,
111 .put_super
= efs_put_super
,
112 .statfs
= efs_statfs
,
113 .remount_fs
= efs_remount
,
116 static struct export_operations efs_export_ops
= {
117 .get_parent
= efs_get_parent
,
120 static int __init
init_efs_fs(void) {
122 printk("EFS: "EFS_VERSION
" - http://aeschi.ch.eu.org/efs/\n");
123 err
= init_inodecache();
126 err
= register_filesystem(&efs_fs_type
);
131 destroy_inodecache();
136 static void __exit
exit_efs_fs(void) {
137 unregister_filesystem(&efs_fs_type
);
138 destroy_inodecache();
141 module_init(init_efs_fs
)
142 module_exit(exit_efs_fs
)
144 static efs_block_t
efs_validate_vh(struct volume_header
*vh
) {
148 efs_block_t sblock
= 0; /* shuts up gcc */
149 struct pt_types
*pt_entry
;
150 int pt_type
, slice
= -1;
152 if (be32_to_cpu(vh
->vh_magic
) != VHMAGIC
) {
154 * assume that we're dealing with a partition and allow
155 * read_super() to try and detect a valid superblock
161 ui
= ((__be32
*) (vh
+ 1)) - 1;
162 for(csum
= 0; ui
>= ((__be32
*) vh
);) {
164 csum
+= be32_to_cpu(cs
);
167 printk(KERN_INFO
"EFS: SGI disklabel: checksum bad, label corrupted\n");
172 printk(KERN_DEBUG
"EFS: bf: \"%16s\"\n", vh
->vh_bootfile
);
174 for(i
= 0; i
< NVDIR
; i
++) {
176 char name
[VDNAMESIZE
+1];
178 for(j
= 0; j
< VDNAMESIZE
; j
++) {
179 name
[j
] = vh
->vh_vd
[i
].vd_name
[j
];
184 printk(KERN_DEBUG
"EFS: vh: %8s block: 0x%08x size: 0x%08x\n",
186 (int) be32_to_cpu(vh
->vh_vd
[i
].vd_lbn
),
187 (int) be32_to_cpu(vh
->vh_vd
[i
].vd_nbytes
));
192 for(i
= 0; i
< NPARTAB
; i
++) {
193 pt_type
= (int) be32_to_cpu(vh
->vh_pt
[i
].pt_type
);
194 for(pt_entry
= sgi_pt_types
; pt_entry
->pt_name
; pt_entry
++) {
195 if (pt_type
== pt_entry
->pt_type
) break;
198 if (be32_to_cpu(vh
->vh_pt
[i
].pt_nblks
)) {
199 printk(KERN_DEBUG
"EFS: pt %2d: start: %08d size: %08d type: 0x%02x (%s)\n",
201 (int) be32_to_cpu(vh
->vh_pt
[i
].pt_firstlbn
),
202 (int) be32_to_cpu(vh
->vh_pt
[i
].pt_nblks
),
204 (pt_entry
->pt_name
) ? pt_entry
->pt_name
: "unknown");
207 if (IS_EFS(pt_type
)) {
208 sblock
= be32_to_cpu(vh
->vh_pt
[i
].pt_firstlbn
);
214 printk(KERN_NOTICE
"EFS: partition table contained no EFS partitions\n");
217 printk(KERN_INFO
"EFS: using slice %d (type %s, offset 0x%x)\n",
219 (pt_entry
->pt_name
) ? pt_entry
->pt_name
: "unknown",
226 static int efs_validate_super(struct efs_sb_info
*sb
, struct efs_super
*super
) {
228 if (!IS_EFS_MAGIC(be32_to_cpu(super
->fs_magic
)))
231 sb
->fs_magic
= be32_to_cpu(super
->fs_magic
);
232 sb
->total_blocks
= be32_to_cpu(super
->fs_size
);
233 sb
->first_block
= be32_to_cpu(super
->fs_firstcg
);
234 sb
->group_size
= be32_to_cpu(super
->fs_cgfsize
);
235 sb
->data_free
= be32_to_cpu(super
->fs_tfree
);
236 sb
->inode_free
= be32_to_cpu(super
->fs_tinode
);
237 sb
->inode_blocks
= be16_to_cpu(super
->fs_cgisize
);
238 sb
->total_groups
= be16_to_cpu(super
->fs_ncg
);
243 static int efs_fill_super(struct super_block
*s
, void *d
, int silent
)
245 struct efs_sb_info
*sb
;
246 struct buffer_head
*bh
;
249 sb
= kzalloc(sizeof(struct efs_sb_info
), GFP_KERNEL
);
254 s
->s_magic
= EFS_SUPER_MAGIC
;
255 if (!sb_set_blocksize(s
, EFS_BLOCKSIZE
)) {
256 printk(KERN_ERR
"EFS: device does not support %d byte blocks\n",
261 /* read the vh (volume header) block */
265 printk(KERN_ERR
"EFS: cannot read volume header\n");
270 * if this returns zero then we didn't find any partition table.
271 * this isn't (yet) an error - just assume for the moment that
272 * the device is valid and go on to search for a superblock.
274 sb
->fs_start
= efs_validate_vh((struct volume_header
*) bh
->b_data
);
277 if (sb
->fs_start
== -1) {
281 bh
= sb_bread(s
, sb
->fs_start
+ EFS_SUPER
);
283 printk(KERN_ERR
"EFS: cannot read superblock\n");
287 if (efs_validate_super(sb
, (struct efs_super
*) bh
->b_data
)) {
289 printk(KERN_WARNING
"EFS: invalid superblock at block %u\n", sb
->fs_start
+ EFS_SUPER
);
296 if (!(s
->s_flags
& MS_RDONLY
)) {
298 printk(KERN_INFO
"EFS: forcing read-only mode\n");
300 s
->s_flags
|= MS_RDONLY
;
302 s
->s_op
= &efs_superblock_operations
;
303 s
->s_export_op
= &efs_export_ops
;
304 root
= iget(s
, EFS_ROOTINODE
);
305 s
->s_root
= d_alloc_root(root
);
308 printk(KERN_ERR
"EFS: get root inode failed\n");
322 static int efs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
) {
323 struct efs_sb_info
*sb
= SUPER_INFO(dentry
->d_sb
);
325 buf
->f_type
= EFS_SUPER_MAGIC
; /* efs magic number */
326 buf
->f_bsize
= EFS_BLOCKSIZE
; /* blocksize */
327 buf
->f_blocks
= sb
->total_groups
* /* total data blocks */
328 (sb
->group_size
- sb
->inode_blocks
);
329 buf
->f_bfree
= sb
->data_free
; /* free data blocks */
330 buf
->f_bavail
= sb
->data_free
; /* free blocks for non-root */
331 buf
->f_files
= sb
->total_groups
* /* total inodes */
333 (EFS_BLOCKSIZE
/ sizeof(struct efs_dinode
));
334 buf
->f_ffree
= sb
->inode_free
; /* free inodes */
335 buf
->f_fsid
.val
[0] = (sb
->fs_magic
>> 16) & 0xffff; /* fs ID */
336 buf
->f_fsid
.val
[1] = sb
->fs_magic
& 0xffff; /* fs ID */
337 buf
->f_namelen
= EFS_MAXNAMELEN
; /* max filename length */