2 * Copyright (c) 2000-2001 Christoph Hellwig.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions, and the following disclaimer,
10 * without modification.
11 * 2. The name of the author may not be used to endorse or promote products
12 * derived from this software without specific prior written permission.
14 * Alternatively, this software may be distributed under the terms of the
15 * GNU General Public License ("GPL").
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
21 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * Veritas filesystem driver - superblock related routines.
33 #include <linux/init.h>
34 #include <linux/module.h>
36 #include <linux/blkdev.h>
38 #include <linux/buffer_head.h>
39 #include <linux/kernel.h>
40 #include <linux/slab.h>
41 #include <linux/stat.h>
42 #include <linux/vfs.h>
43 #include <linux/mount.h>
46 #include "vxfs_extern.h"
48 #include "vxfs_inode.h"
51 MODULE_AUTHOR("Christoph Hellwig");
52 MODULE_DESCRIPTION("Veritas Filesystem (VxFS) driver");
53 MODULE_LICENSE("Dual BSD/GPL");
57 static void vxfs_put_super(struct super_block
*);
58 static int vxfs_statfs(struct dentry
*, struct kstatfs
*);
59 static int vxfs_remount(struct super_block
*, int *, char *);
61 static const struct super_operations vxfs_super_ops
= {
62 .evict_inode
= vxfs_evict_inode
,
63 .put_super
= vxfs_put_super
,
64 .statfs
= vxfs_statfs
,
65 .remount_fs
= vxfs_remount
,
69 * vxfs_put_super - free superblock resources
70 * @sbp: VFS superblock.
73 * vxfs_put_super frees all resources allocated for @sbp
74 * after the last instance of the filesystem is unmounted.
78 vxfs_put_super(struct super_block
*sbp
)
80 struct vxfs_sb_info
*infp
= VXFS_SBI(sbp
);
82 vxfs_put_fake_inode(infp
->vsi_fship
);
83 vxfs_put_fake_inode(infp
->vsi_ilist
);
84 vxfs_put_fake_inode(infp
->vsi_stilist
);
91 * vxfs_statfs - get filesystem information
92 * @dentry: VFS dentry to locate superblock
93 * @bufp: output buffer
96 * vxfs_statfs fills the statfs buffer @bufp with information
97 * about the filesystem described by @dentry.
106 * This is everything but complete...
109 vxfs_statfs(struct dentry
*dentry
, struct kstatfs
*bufp
)
111 struct vxfs_sb_info
*infp
= VXFS_SBI(dentry
->d_sb
);
112 struct vxfs_sb
*raw_sb
= infp
->vsi_raw
;
114 bufp
->f_type
= VXFS_SUPER_MAGIC
;
115 bufp
->f_bsize
= dentry
->d_sb
->s_blocksize
;
116 bufp
->f_blocks
= fs32_to_cpu(infp
, raw_sb
->vs_dsize
);
117 bufp
->f_bfree
= fs32_to_cpu(infp
, raw_sb
->vs_free
);
120 bufp
->f_ffree
= fs32_to_cpu(infp
, raw_sb
->vs_ifree
);
121 bufp
->f_namelen
= VXFS_NAMELEN
;
126 static int vxfs_remount(struct super_block
*sb
, int *flags
, char *data
)
134 static int vxfs_try_sb_magic(struct super_block
*sbp
, int silent
,
135 unsigned blk
, __fs32 magic
)
137 struct buffer_head
*bp
;
138 struct vxfs_sb
*rsbp
;
139 struct vxfs_sb_info
*infp
= VXFS_SBI(sbp
);
142 bp
= sb_bread(sbp
, blk
);
144 if (!bp
|| !buffer_mapped(bp
)) {
147 "vxfs: unable to read disk superblock at %u\n",
154 rsbp
= (struct vxfs_sb
*)bp
->b_data
;
155 if (rsbp
->vs_magic
!= magic
) {
158 "vxfs: WRONG superblock magic %08x at %u\n",
159 rsbp
->vs_magic
, blk
);
164 infp
->vsi_raw
= rsbp
;
169 infp
->vsi_raw
= NULL
;
178 * vxfs_read_super - read superblock into memory and initialize filesystem
179 * @sbp: VFS superblock (to fill)
180 * @dp: fs private mount data
181 * @silent: do not complain loudly when sth is wrong
184 * We are called on the first mount of a filesystem to read the
185 * superblock into memory and do some basic setup.
188 * The superblock on success, else %NULL.
191 * We are under @sbp->s_lock.
193 static int vxfs_fill_super(struct super_block
*sbp
, void *dp
, int silent
)
195 struct vxfs_sb_info
*infp
;
196 struct vxfs_sb
*rsbp
;
202 sbp
->s_flags
|= MS_RDONLY
;
204 infp
= kzalloc(sizeof(*infp
), GFP_KERNEL
);
206 printk(KERN_WARNING
"vxfs: unable to allocate incore superblock\n");
210 bsize
= sb_min_blocksize(sbp
, BLOCK_SIZE
);
212 printk(KERN_WARNING
"vxfs: unable to set blocksize\n");
216 sbp
->s_fs_info
= infp
;
218 if (!vxfs_try_sb_magic(sbp
, silent
, 1,
219 (__force __fs32
)cpu_to_le32(VXFS_SUPER_MAGIC
))) {
221 infp
->byte_order
= VXFS_BO_LE
;
222 } else if (!vxfs_try_sb_magic(sbp
, silent
, 8,
223 (__force __fs32
)cpu_to_be32(VXFS_SUPER_MAGIC
))) {
225 infp
->byte_order
= VXFS_BO_BE
;
228 printk(KERN_NOTICE
"vxfs: can't find superblock.\n");
232 rsbp
= infp
->vsi_raw
;
233 j
= fs32_to_cpu(infp
, rsbp
->vs_version
);
234 if ((j
< 2 || j
> 4) && !silent
) {
235 printk(KERN_NOTICE
"vxfs: unsupported VxFS version (%d)\n", j
);
240 printk(KERN_DEBUG
"vxfs: supported VxFS version (%d)\n", j
);
241 printk(KERN_DEBUG
"vxfs: blocksize: %d\n",
242 fs32_to_cpu(infp
, rsbp
->vs_bsize
));
245 sbp
->s_magic
= fs32_to_cpu(infp
, rsbp
->vs_magic
);
247 infp
->vsi_oltext
= fs32_to_cpu(infp
, rsbp
->vs_oltext
[0]);
248 infp
->vsi_oltsize
= fs32_to_cpu(infp
, rsbp
->vs_oltsize
);
250 j
= fs32_to_cpu(infp
, rsbp
->vs_bsize
);
251 if (!sb_set_blocksize(sbp
, j
)) {
252 printk(KERN_WARNING
"vxfs: unable to set final block size\n");
256 if (vxfs_read_olt(sbp
, bsize
)) {
257 printk(KERN_WARNING
"vxfs: unable to read olt\n");
261 if (vxfs_read_fshead(sbp
)) {
262 printk(KERN_WARNING
"vxfs: unable to read fshead\n");
266 sbp
->s_op
= &vxfs_super_ops
;
267 root
= vxfs_iget(sbp
, VXFS_ROOT_INO
);
272 sbp
->s_root
= d_make_root(root
);
274 printk(KERN_WARNING
"vxfs: unable to get root dentry.\n");
281 vxfs_put_fake_inode(infp
->vsi_fship
);
282 vxfs_put_fake_inode(infp
->vsi_ilist
);
283 vxfs_put_fake_inode(infp
->vsi_stilist
);
285 brelse(infp
->vsi_bp
);
291 * The usual module blurb.
293 static struct dentry
*vxfs_mount(struct file_system_type
*fs_type
,
294 int flags
, const char *dev_name
, void *data
)
296 return mount_bdev(fs_type
, flags
, dev_name
, data
, vxfs_fill_super
);
299 static struct file_system_type vxfs_fs_type
= {
300 .owner
= THIS_MODULE
,
303 .kill_sb
= kill_block_super
,
304 .fs_flags
= FS_REQUIRES_DEV
,
306 MODULE_ALIAS_FS("vxfs"); /* makes mount -t vxfs autoload the module */
307 MODULE_ALIAS("vxfs");
314 vxfs_inode_cachep
= kmem_cache_create("vxfs_inode",
315 sizeof(struct vxfs_inode_info
), 0,
316 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
, NULL
);
317 if (!vxfs_inode_cachep
)
319 rv
= register_filesystem(&vxfs_fs_type
);
321 kmem_cache_destroy(vxfs_inode_cachep
);
328 unregister_filesystem(&vxfs_fs_type
);
330 * Make sure all delayed rcu free inodes are flushed before we
334 kmem_cache_destroy(vxfs_inode_cachep
);
337 module_init(vxfs_init
);
338 module_exit(vxfs_cleanup
);