fs/freevxfs/vxfs_super.c

   1 /*
   2  * Copyright (c) 2000-2001 Christoph Hellwig.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   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.
  13  *
  14  * Alternatively, this software may be distributed under the terms of the
  15  * GNU General Public License ("GPL").
  16  *
  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
  27  * SUCH DAMAGE.
  28  */
  29
  30 #ident "$Id: vxfs_super.c,v 1.29 2002/01/02 22:02:12 hch Exp hch $"
  31
  32 /*
  33  * Veritas filesystem driver - superblock related routines.
  34  */
  35 #include <linux/init.h>
  36 #include <linux/module.h>
  37
  38 #include <linux/blkdev.h>
  39 #include <linux/fs.h>
  40 #include <linux/kernel.h>
  41 #include <linux/slab.h>
  42 #include <linux/stat.h>
  43
  44 #include "vxfs.h"
  45 #include "vxfs_extern.h"
  46 #include "vxfs_dir.h"
  47 #include "vxfs_inode.h"
  48
  49
  50 MODULE_AUTHOR("Christoph Hellwig");
  51 MODULE_DESCRIPTION("Veritas Filesystem (VxFS) driver");
  52 MODULE_LICENSE("Dual BSD/GPL");
  53
  54
  55 static void             vxfs_put_super(struct super_block *);
  56 static int              vxfs_statfs(struct super_block *, struct statfs *);
  57
  58 static struct super_operations vxfs_super_ops = {
  59         .read_inode =           vxfs_read_inode,
  60         .put_inode =            vxfs_put_inode,
  61         .put_super =            vxfs_put_super,
  62         .statfs =               vxfs_statfs,
  63 };
  64
  65 /**
  66  * vxfs_put_super - free superblock resources
  67  * @sbp:        VFS superblock.
  68  *
  69  * Description:
  70  *   vxfs_put_super frees all resources allocated for @sbp
  71  *   after the last instance of the filesystem is unmounted.
  72  */
  73
  74 static void
  75 vxfs_put_super(struct super_block *sbp)
  76 {
  77         struct vxfs_sb_info     *infp = VXFS_SBI(sbp);
  78
  79         vxfs_put_fake_inode(infp->vsi_fship);
  80         vxfs_put_fake_inode(infp->vsi_ilist);
  81         vxfs_put_fake_inode(infp->vsi_stilist);
  82
  83         brelse(infp->vsi_bp);
  84         kfree(infp);
  85 }
  86
  87 /**
  88  * vxfs_statfs - get filesystem information
  89  * @sbp:        VFS superblock
  90  * @bufp:       output buffer
  91  *
  92  * Description:
  93  *   vxfs_statfs fills the statfs buffer @bufp with information
  94  *   about the filesystem described by @sbp.
  95  *
  96  * Returns:
  97  *   Zero.
  98  *
  99  * Locking:
 100  *   We are under bkl and @sbp->s_lock.
 101  *
 102  * Notes:
 103  *   This is everything but complete...
 104  */
 105 static int
 106 vxfs_statfs(struct super_block *sbp, struct statfs *bufp)
 107 {
 108         struct vxfs_sb_info             *infp = VXFS_SBI(sbp);
 109
 110         bufp->f_type = VXFS_SUPER_MAGIC;
 111         bufp->f_bsize = sbp->s_blocksize;
 112         bufp->f_blocks = infp->vsi_raw->vs_dsize;
 113         bufp->f_bfree = infp->vsi_raw->vs_free;
 114         bufp->f_bavail = 0;
 115         bufp->f_files = 0;
 116         bufp->f_ffree = infp->vsi_raw->vs_ifree;
 117         bufp->f_namelen = VXFS_NAMELEN;
 118
 119         return 0;
 120 }
 121
 122 /**
 123  * vxfs_read_super - read superblock into memory and initalize filesystem
 124  * @sbp:                VFS superblock (to fill)
 125  * @dp:                 fs private mount data
 126  * @silent:             do not complain loudly when sth is wrong
 127  *
 128  * Description:
 129  *   We are called on the first mount of a filesystem to read the
 130  *   superblock into memory and do some basic setup.
 131  *
 132  * Returns:
 133  *   The superblock on success, else %NULL.
 134  *
 135  * Locking:
 136  *   We are under the bkl and @sbp->s_lock.
 137  */
 138 static struct super_block *
 139 vxfs_read_super(struct super_block *sbp, void *dp, int silent)
 140 {
 141         struct vxfs_sb_info     *infp;
 142         struct vxfs_sb          *rsbp;
 143         struct buffer_head      *bp = NULL;
 144         u_long                  bsize;
 145
 146         infp = kmalloc(sizeof(*infp), GFP_KERNEL);
 147         if (!infp) {
 148                 printk(KERN_WARNING "vxfs: unable to allocate incore superblock\n");
 149                 return NULL;
 150         }
 151         memset(infp, 0, sizeof(*infp));
 152
 153         bsize = sb_min_blocksize(sbp, BLOCK_SIZE);
 154         if (!bsize) {
 155                 printk(KERN_WARNING "vxfs: unable to set blocksize\n");
 156                 goto out;
 157         }
 158
 159         bp = sb_bread(sbp, 1);
 160         if (!bp || !buffer_mapped(bp)) {
 161                 if (!silent) {
 162                         printk(KERN_WARNING
 163                                 "vxfs: unable to read disk superblock\n");
 164                 }
 165                 goto out;
 166         }
 167
 168         rsbp = (struct vxfs_sb *)bp->b_data;
 169         if (rsbp->vs_magic != VXFS_SUPER_MAGIC) {
 170                 if (!silent)
 171                         printk(KERN_NOTICE "vxfs: WRONG superblock magic\n");
 172                 goto out;
 173         }
 174
 175         if ((rsbp->vs_version < 2 || rsbp->vs_version > 4) && !silent) {
 176                 printk(KERN_NOTICE "vxfs: unsupported VxFS version (%d)\n",
 177                        rsbp->vs_version);
 178                 goto out;
 179         }
 180
 181 #ifdef DIAGNOSTIC
 182         printk(KERN_DEBUG "vxfs: supported VxFS version (%d)\n", rsbp->vs_version);
 183         printk(KERN_DEBUG "vxfs: blocksize: %d\n", rsbp->vs_bsize);
 184 #endif
 185
 186         sbp->s_magic = rsbp->vs_magic;
 187         sbp->u.generic_sbp = (void *)infp;
 188
 189         infp->vsi_raw = rsbp;
 190         infp->vsi_bp = bp;
 191         infp->vsi_oltext = rsbp->vs_oltext[0];
 192         infp->vsi_oltsize = rsbp->vs_oltsize;
 193
 194         if (!sb_set_blocksize(sbp, rsbp->vs_bsize)) {
 195                 printk(KERN_WARNING "vxfs: unable to set final block size\n");
 196                 goto out;
 197         }
 198
 199         if (vxfs_read_olt(sbp, bsize)) {
 200                 printk(KERN_WARNING "vxfs: unable to read olt\n");
 201                 goto out;
 202         }
 203
 204         if (vxfs_read_fshead(sbp)) {
 205                 printk(KERN_WARNING "vxfs: unable to read fshead\n");
 206                 goto out;
 207         }
 208
 209         sbp->s_op = &vxfs_super_ops;
 210         sbp->s_root = d_alloc_root(iget(sbp, VXFS_ROOT_INO));
 211         if (!sbp->s_root) {
 212                 printk(KERN_WARNING "vxfs: unable to get root dentry.\n");
 213                 goto out_free_ilist;
 214         }
 215
 216         return (sbp);
 217
 218 out_free_ilist:
 219         vxfs_put_fake_inode(infp->vsi_fship);
 220         vxfs_put_fake_inode(infp->vsi_ilist);
 221         vxfs_put_fake_inode(infp->vsi_stilist);
 222 out:
 223         brelse(bp);
 224         kfree(infp);
 225         return NULL;
 226 }
 227
 228 /*
 229  * The usual module blurb.
 230  */
 231 static DECLARE_FSTYPE_DEV(vxfs_fs_type, "vxfs", vxfs_read_super);
 232
 233 static int __init
 234 vxfs_init(void)
 235 {
 236         vxfs_inode_cachep = kmem_cache_create("vxfs_inode",
 237                         sizeof(struct vxfs_inode_info), 0, 0, NULL, NULL);
 238         if (vxfs_inode_cachep)
 239                 return (register_filesystem(&vxfs_fs_type));
 240         return -ENOMEM;
 241 }
 242
 243 static void __exit
 244 vxfs_cleanup(void)
 245 {
 246         unregister_filesystem(&vxfs_fs_type);
 247         kmem_cache_destroy(vxfs_inode_cachep);
 248 }
 249
 250 module_init(vxfs_init);
 251 module_exit(vxfs_cleanup);