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/locks.h>
12 #include <linux/efs_fs.h>
13 #include <linux/efs_vh.h>
14 #include <linux/efs_fs_sb.h>
16 static DECLARE_FSTYPE_DEV(efs_fs_type
, "efs", efs_read_super
);
18 static struct super_operations efs_superblock_operations
= {
19 read_inode
: efs_read_inode
,
23 static int __init
init_efs_fs(void) {
24 printk("EFS: "EFS_VERSION
" - http://aeschi.ch.eu.org/efs/\n");
25 return register_filesystem(&efs_fs_type
);
28 static void __exit
exit_efs_fs(void) {
29 unregister_filesystem(&efs_fs_type
);
34 module_init(init_efs_fs
)
35 module_exit(exit_efs_fs
)
37 static efs_block_t
efs_validate_vh(struct volume_header
*vh
) {
39 unsigned int cs
, csum
, *ui
;
40 efs_block_t sblock
= 0; /* shuts up gcc */
41 struct pt_types
*pt_entry
;
42 int pt_type
, slice
= -1;
44 if (be32_to_cpu(vh
->vh_magic
) != VHMAGIC
) {
46 * assume that we're dealing with a partition and allow
47 * read_super() to try and detect a valid superblock
53 ui
= ((unsigned int *) (vh
+ 1)) - 1;
54 for(csum
= 0; ui
>= ((unsigned int *) vh
);) {
56 csum
+= be32_to_cpu(cs
);
59 printk(KERN_INFO
"EFS: SGI disklabel: checksum bad, label corrupted\n");
64 printk(KERN_DEBUG
"EFS: bf: \"%16s\"\n", vh
->vh_bootfile
);
66 for(i
= 0; i
< NVDIR
; i
++) {
68 char name
[VDNAMESIZE
+1];
70 for(j
= 0; j
< VDNAMESIZE
; j
++) {
71 name
[j
] = vh
->vh_vd
[i
].vd_name
[j
];
76 printk(KERN_DEBUG
"EFS: vh: %8s block: 0x%08x size: 0x%08x\n",
78 (int) be32_to_cpu(vh
->vh_vd
[i
].vd_lbn
),
79 (int) be32_to_cpu(vh
->vh_vd
[i
].vd_nbytes
));
84 for(i
= 0; i
< NPARTAB
; i
++) {
85 pt_type
= (int) be32_to_cpu(vh
->vh_pt
[i
].pt_type
);
86 for(pt_entry
= sgi_pt_types
; pt_entry
->pt_name
; pt_entry
++) {
87 if (pt_type
== pt_entry
->pt_type
) break;
90 if (be32_to_cpu(vh
->vh_pt
[i
].pt_nblks
)) {
91 printk(KERN_DEBUG
"EFS: pt %2d: start: %08d size: %08d type: 0x%02x (%s)\n",
93 (int) be32_to_cpu(vh
->vh_pt
[i
].pt_firstlbn
),
94 (int) be32_to_cpu(vh
->vh_pt
[i
].pt_nblks
),
96 (pt_entry
->pt_name
) ? pt_entry
->pt_name
: "unknown");
99 if (IS_EFS(pt_type
)) {
100 sblock
= be32_to_cpu(vh
->vh_pt
[i
].pt_firstlbn
);
106 printk(KERN_NOTICE
"EFS: partition table contained no EFS partitions\n");
109 printk(KERN_INFO
"EFS: using slice %d (type %s, offset 0x%x)\n",
111 (pt_entry
->pt_name
) ? pt_entry
->pt_name
: "unknown",
118 static int efs_validate_super(struct efs_sb_info
*sb
, struct efs_super
*super
) {
120 if (!IS_EFS_MAGIC(be32_to_cpu(super
->fs_magic
))) return -1;
122 sb
->fs_magic
= be32_to_cpu(super
->fs_magic
);
123 sb
->total_blocks
= be32_to_cpu(super
->fs_size
);
124 sb
->first_block
= be32_to_cpu(super
->fs_firstcg
);
125 sb
->group_size
= be32_to_cpu(super
->fs_cgfsize
);
126 sb
->data_free
= be32_to_cpu(super
->fs_tfree
);
127 sb
->inode_free
= be32_to_cpu(super
->fs_tinode
);
128 sb
->inode_blocks
= be16_to_cpu(super
->fs_cgisize
);
129 sb
->total_groups
= be16_to_cpu(super
->fs_ncg
);
134 struct super_block
*efs_read_super(struct super_block
*s
, void *d
, int silent
) {
135 kdev_t dev
= s
->s_dev
;
136 struct efs_sb_info
*sb
;
137 struct buffer_head
*bh
;
141 set_blocksize(dev
, EFS_BLOCKSIZE
);
143 /* read the vh (volume header) block */
144 bh
= bread(dev
, 0, EFS_BLOCKSIZE
);
147 printk(KERN_ERR
"EFS: cannot read volume header\n");
152 * if this returns zero then we didn't find any partition table.
153 * this isn't (yet) an error - just assume for the moment that
154 * the device is valid and go on to search for a superblock.
156 sb
->fs_start
= efs_validate_vh((struct volume_header
*) bh
->b_data
);
159 if (sb
->fs_start
== -1) {
163 bh
= bread(dev
, sb
->fs_start
+ EFS_SUPER
, EFS_BLOCKSIZE
);
165 printk(KERN_ERR
"EFS: cannot read superblock\n");
169 if (efs_validate_super(sb
, (struct efs_super
*) bh
->b_data
)) {
171 printk(KERN_WARNING
"EFS: invalid superblock at block %u\n", sb
->fs_start
+ EFS_SUPER
);
178 s
->s_magic
= EFS_SUPER_MAGIC
;
179 s
->s_blocksize
= EFS_BLOCKSIZE
;
180 s
->s_blocksize_bits
= EFS_BLOCKSIZE_BITS
;
181 if (!(s
->s_flags
& MS_RDONLY
)) {
183 printk(KERN_INFO
"EFS: forcing read-only mode\n");
185 s
->s_flags
|= MS_RDONLY
;
187 s
->s_op
= &efs_superblock_operations
;
188 s
->s_root
= d_alloc_root(iget(s
, EFS_ROOTINODE
));
191 printk(KERN_ERR
"EFS: get root inode failed\n");
202 int efs_statfs(struct super_block
*s
, struct statfs
*buf
) {
203 struct efs_sb_info
*sb
= SUPER_INFO(s
);
205 buf
->f_type
= EFS_SUPER_MAGIC
; /* efs magic number */
206 buf
->f_bsize
= EFS_BLOCKSIZE
; /* blocksize */
207 buf
->f_blocks
= sb
->total_groups
* /* total data blocks */
208 (sb
->group_size
- sb
->inode_blocks
);
209 buf
->f_bfree
= sb
->data_free
; /* free data blocks */
210 buf
->f_bavail
= sb
->data_free
; /* free blocks for non-root */
211 buf
->f_files
= sb
->total_groups
* /* total inodes */
213 (EFS_BLOCKSIZE
/ sizeof(struct efs_dinode
));
214 buf
->f_ffree
= sb
->inode_free
; /* free inodes */
215 buf
->f_fsid
.val
[0] = (sb
->fs_magic
>> 16) & 0xffff; /* fs ID */
216 buf
->f_fsid
.val
[1] = sb
->fs_magic
& 0xffff; /* fs ID */
217 buf
->f_namelen
= EFS_MAXNAMELEN
; /* max filename length */