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 <<<<<<< HEAD
:fs
/efs
/super
.c
12 #include <linux/efs_fs.h>
13 #include <linux/efs_vh.h>
14 #include <linux/efs_fs_sb.h>
16 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:fs
/efs
/super
.c
17 #include <linux/exportfs.h>
18 #include <linux/slab.h>
19 #include <linux/buffer_head.h>
20 #include <linux/vfs.h>
22 <<<<<<< HEAD
:fs
/efs
/super
.c
25 #include <linux/efs_vh.h>
26 #include <linux/efs_fs_sb.h>
28 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:fs
/efs
/super
.c
29 static int efs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
);
30 static int efs_fill_super(struct super_block
*s
, void *d
, int silent
);
32 static int efs_get_sb(struct file_system_type
*fs_type
,
33 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
35 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, efs_fill_super
, mnt
);
38 static struct file_system_type efs_fs_type
= {
42 .kill_sb
= kill_block_super
,
43 .fs_flags
= FS_REQUIRES_DEV
,
46 static struct pt_types sgi_pt_types
[] = {
48 {0x01, "SGI trkrepl"},
49 {0x02, "SGI secrepl"},
52 {SGI_SYSV
, "SGI sysv"},
61 {0x83, "Linux native"},
66 static struct kmem_cache
* efs_inode_cachep
;
68 static struct inode
*efs_alloc_inode(struct super_block
*sb
)
70 struct efs_inode_info
*ei
;
71 ei
= (struct efs_inode_info
*)kmem_cache_alloc(efs_inode_cachep
, GFP_KERNEL
);
74 return &ei
->vfs_inode
;
77 static void efs_destroy_inode(struct inode
*inode
)
79 kmem_cache_free(efs_inode_cachep
, INODE_INFO(inode
));
82 static void init_once(struct kmem_cache
*cachep
, void *foo
)
84 struct efs_inode_info
*ei
= (struct efs_inode_info
*) foo
;
86 inode_init_once(&ei
->vfs_inode
);
89 static int init_inodecache(void)
91 efs_inode_cachep
= kmem_cache_create("efs_inode_cache",
92 sizeof(struct efs_inode_info
),
93 0, SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
,
95 if (efs_inode_cachep
== NULL
)
100 static void destroy_inodecache(void)
102 kmem_cache_destroy(efs_inode_cachep
);
105 static void efs_put_super(struct super_block
*s
)
111 static int efs_remount(struct super_block
*sb
, int *flags
, char *data
)
117 static const struct super_operations efs_superblock_operations
= {
118 .alloc_inode
= efs_alloc_inode
,
119 .destroy_inode
= efs_destroy_inode
,
120 .put_super
= efs_put_super
,
121 .statfs
= efs_statfs
,
122 .remount_fs
= efs_remount
,
125 static const struct export_operations efs_export_ops
= {
126 .fh_to_dentry
= efs_fh_to_dentry
,
127 .fh_to_parent
= efs_fh_to_parent
,
128 .get_parent
= efs_get_parent
,
131 static int __init
init_efs_fs(void) {
133 printk("EFS: "EFS_VERSION
" - http://aeschi.ch.eu.org/efs/\n");
134 err
= init_inodecache();
137 err
= register_filesystem(&efs_fs_type
);
142 destroy_inodecache();
147 static void __exit
exit_efs_fs(void) {
148 unregister_filesystem(&efs_fs_type
);
149 destroy_inodecache();
152 module_init(init_efs_fs
)
153 module_exit(exit_efs_fs
)
155 static efs_block_t
efs_validate_vh(struct volume_header
*vh
) {
159 efs_block_t sblock
= 0; /* shuts up gcc */
160 struct pt_types
*pt_entry
;
161 int pt_type
, slice
= -1;
163 if (be32_to_cpu(vh
->vh_magic
) != VHMAGIC
) {
165 * assume that we're dealing with a partition and allow
166 * read_super() to try and detect a valid superblock
172 ui
= ((__be32
*) (vh
+ 1)) - 1;
173 for(csum
= 0; ui
>= ((__be32
*) vh
);) {
175 csum
+= be32_to_cpu(cs
);
178 printk(KERN_INFO
"EFS: SGI disklabel: checksum bad, label corrupted\n");
183 printk(KERN_DEBUG
"EFS: bf: \"%16s\"\n", vh
->vh_bootfile
);
185 for(i
= 0; i
< NVDIR
; i
++) {
187 char name
[VDNAMESIZE
+1];
189 for(j
= 0; j
< VDNAMESIZE
; j
++) {
190 name
[j
] = vh
->vh_vd
[i
].vd_name
[j
];
195 printk(KERN_DEBUG
"EFS: vh: %8s block: 0x%08x size: 0x%08x\n",
197 (int) be32_to_cpu(vh
->vh_vd
[i
].vd_lbn
),
198 (int) be32_to_cpu(vh
->vh_vd
[i
].vd_nbytes
));
203 for(i
= 0; i
< NPARTAB
; i
++) {
204 pt_type
= (int) be32_to_cpu(vh
->vh_pt
[i
].pt_type
);
205 for(pt_entry
= sgi_pt_types
; pt_entry
->pt_name
; pt_entry
++) {
206 if (pt_type
== pt_entry
->pt_type
) break;
209 if (be32_to_cpu(vh
->vh_pt
[i
].pt_nblks
)) {
210 printk(KERN_DEBUG
"EFS: pt %2d: start: %08d size: %08d type: 0x%02x (%s)\n",
212 (int) be32_to_cpu(vh
->vh_pt
[i
].pt_firstlbn
),
213 (int) be32_to_cpu(vh
->vh_pt
[i
].pt_nblks
),
215 (pt_entry
->pt_name
) ? pt_entry
->pt_name
: "unknown");
218 if (IS_EFS(pt_type
)) {
219 sblock
= be32_to_cpu(vh
->vh_pt
[i
].pt_firstlbn
);
225 printk(KERN_NOTICE
"EFS: partition table contained no EFS partitions\n");
228 printk(KERN_INFO
"EFS: using slice %d (type %s, offset 0x%x)\n",
230 (pt_entry
->pt_name
) ? pt_entry
->pt_name
: "unknown",
237 static int efs_validate_super(struct efs_sb_info
*sb
, struct efs_super
*super
) {
239 if (!IS_EFS_MAGIC(be32_to_cpu(super
->fs_magic
)))
242 sb
->fs_magic
= be32_to_cpu(super
->fs_magic
);
243 sb
->total_blocks
= be32_to_cpu(super
->fs_size
);
244 sb
->first_block
= be32_to_cpu(super
->fs_firstcg
);
245 sb
->group_size
= be32_to_cpu(super
->fs_cgfsize
);
246 sb
->data_free
= be32_to_cpu(super
->fs_tfree
);
247 sb
->inode_free
= be32_to_cpu(super
->fs_tinode
);
248 sb
->inode_blocks
= be16_to_cpu(super
->fs_cgisize
);
249 sb
->total_groups
= be16_to_cpu(super
->fs_ncg
);
254 static int efs_fill_super(struct super_block
*s
, void *d
, int silent
)
256 struct efs_sb_info
*sb
;
257 struct buffer_head
*bh
;
261 sb
= kzalloc(sizeof(struct efs_sb_info
), GFP_KERNEL
);
266 s
->s_magic
= EFS_SUPER_MAGIC
;
267 if (!sb_set_blocksize(s
, EFS_BLOCKSIZE
)) {
268 printk(KERN_ERR
"EFS: device does not support %d byte blocks\n",
273 /* read the vh (volume header) block */
277 printk(KERN_ERR
"EFS: cannot read volume header\n");
282 * if this returns zero then we didn't find any partition table.
283 * this isn't (yet) an error - just assume for the moment that
284 * the device is valid and go on to search for a superblock.
286 sb
->fs_start
= efs_validate_vh((struct volume_header
*) bh
->b_data
);
289 if (sb
->fs_start
== -1) {
293 bh
= sb_bread(s
, sb
->fs_start
+ EFS_SUPER
);
295 printk(KERN_ERR
"EFS: cannot read superblock\n");
299 if (efs_validate_super(sb
, (struct efs_super
*) bh
->b_data
)) {
301 printk(KERN_WARNING
"EFS: invalid superblock at block %u\n", sb
->fs_start
+ EFS_SUPER
);
308 if (!(s
->s_flags
& MS_RDONLY
)) {
310 printk(KERN_INFO
"EFS: forcing read-only mode\n");
312 s
->s_flags
|= MS_RDONLY
;
314 s
->s_op
= &efs_superblock_operations
;
315 s
->s_export_op
= &efs_export_ops
;
316 root
= efs_iget(s
, EFS_ROOTINODE
);
318 printk(KERN_ERR
"EFS: get root inode failed\n");
323 s
->s_root
= d_alloc_root(root
);
325 printk(KERN_ERR
"EFS: get root dentry failed\n");
340 static int efs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
) {
341 struct efs_sb_info
*sb
= SUPER_INFO(dentry
->d_sb
);
343 buf
->f_type
= EFS_SUPER_MAGIC
; /* efs magic number */
344 buf
->f_bsize
= EFS_BLOCKSIZE
; /* blocksize */
345 buf
->f_blocks
= sb
->total_groups
* /* total data blocks */
346 (sb
->group_size
- sb
->inode_blocks
);
347 buf
->f_bfree
= sb
->data_free
; /* free data blocks */
348 buf
->f_bavail
= sb
->data_free
; /* free blocks for non-root */
349 buf
->f_files
= sb
->total_groups
* /* total inodes */
351 (EFS_BLOCKSIZE
/ sizeof(struct efs_dinode
));
352 buf
->f_ffree
= sb
->inode_free
; /* free inodes */
353 buf
->f_fsid
.val
[0] = (sb
->fs_magic
>> 16) & 0xffff; /* fs ID */
354 buf
->f_fsid
.val
[1] = sb
->fs_magic
& 0xffff; /* fs ID */
355 buf
->f_namelen
= EFS_MAXNAMELEN
; /* max filename length */