vxfs_super.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    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);

Cache object: 8b9eb43ac8994b55915aa12c80caccc2

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/fs/freevxfs/vxfs_super.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/freevxfs/vxfs_super.c