vxfs_super.c 8.66 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 * Copyright (c) 2000-2001 Christoph Hellwig.
3
 * Copyright (c) 2016 Krzysztof Blaszkowski
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL").
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * Veritas filesystem driver - superblock related routines.
 */
#include <linux/init.h>
#include <linux/module.h>

#include <linux/blkdev.h>
#include <linux/fs.h>
#include <linux/buffer_head.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/stat.h>
#include <linux/vfs.h>
44
#include <linux/mount.h>
Linus Torvalds's avatar
Linus Torvalds committed
45 46 47 48 49 50 51

#include "vxfs.h"
#include "vxfs_extern.h"
#include "vxfs_dir.h"
#include "vxfs_inode.h"


52
MODULE_AUTHOR("Christoph Hellwig, Krzysztof Blaszkowski");
Linus Torvalds's avatar
Linus Torvalds committed
53 54 55
MODULE_DESCRIPTION("Veritas Filesystem (VxFS) driver");
MODULE_LICENSE("Dual BSD/GPL");

56 57
static struct kmem_cache *vxfs_inode_cachep;

Linus Torvalds's avatar
Linus Torvalds committed
58 59 60 61 62 63 64 65 66 67 68 69 70 71
/**
 * vxfs_put_super - free superblock resources
 * @sbp:	VFS superblock.
 *
 * Description:
 *   vxfs_put_super frees all resources allocated for @sbp
 *   after the last instance of the filesystem is unmounted.
 */

static void
vxfs_put_super(struct super_block *sbp)
{
	struct vxfs_sb_info	*infp = VXFS_SBI(sbp);

72 73 74
	iput(infp->vsi_fship);
	iput(infp->vsi_ilist);
	iput(infp->vsi_stilist);
Linus Torvalds's avatar
Linus Torvalds committed
75 76 77 78 79 80 81

	brelse(infp->vsi_bp);
	kfree(infp);
}

/**
 * vxfs_statfs - get filesystem information
82
 * @dentry:	VFS dentry to locate superblock
Linus Torvalds's avatar
Linus Torvalds committed
83 84 85 86
 * @bufp:	output buffer
 *
 * Description:
 *   vxfs_statfs fills the statfs buffer @bufp with information
87
 *   about the filesystem described by @dentry.
Linus Torvalds's avatar
Linus Torvalds committed
88 89 90 91 92 93 94 95 96 97 98
 *
 * Returns:
 *   Zero.
 *
 * Locking:
 *   No locks held.
 *
 * Notes:
 *   This is everything but complete...
 */
static int
99
vxfs_statfs(struct dentry *dentry, struct kstatfs *bufp)
Linus Torvalds's avatar
Linus Torvalds committed
100
{
101
	struct vxfs_sb_info		*infp = VXFS_SBI(dentry->d_sb);
102
	struct vxfs_sb *raw_sb = infp->vsi_raw;
Linus Torvalds's avatar
Linus Torvalds committed
103 104

	bufp->f_type = VXFS_SUPER_MAGIC;
105
	bufp->f_bsize = dentry->d_sb->s_blocksize;
106 107
	bufp->f_blocks = fs32_to_cpu(infp, raw_sb->vs_dsize);
	bufp->f_bfree = fs32_to_cpu(infp, raw_sb->vs_free);
Linus Torvalds's avatar
Linus Torvalds committed
108 109
	bufp->f_bavail = 0;
	bufp->f_files = 0;
110
	bufp->f_ffree = fs32_to_cpu(infp, raw_sb->vs_ifree);
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114 115 116 117
	bufp->f_namelen = VXFS_NAMELEN;

	return 0;
}

static int vxfs_remount(struct super_block *sb, int *flags, char *data)
{
118
	sync_filesystem(sb);
Linus Torvalds's avatar
Linus Torvalds committed
119 120 121 122
	*flags |= MS_RDONLY;
	return 0;
}

123 124 125 126 127 128 129
static struct inode *vxfs_alloc_inode(struct super_block *sb)
{
	struct vxfs_inode_info *vi;

	vi = kmem_cache_alloc(vxfs_inode_cachep, GFP_KERNEL);
	if (!vi)
		return NULL;
130
	inode_init_once(&vi->vfs_inode);
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
	return &vi->vfs_inode;
}

static void vxfs_i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);

	kmem_cache_free(vxfs_inode_cachep, VXFS_INO(inode));
}

static void vxfs_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, vxfs_i_callback);
}

146
static const struct super_operations vxfs_super_ops = {
147 148
	.alloc_inode		= vxfs_alloc_inode,
	.destroy_inode		= vxfs_destroy_inode,
149 150 151 152 153
	.evict_inode		= vxfs_evict_inode,
	.put_super		= vxfs_put_super,
	.statfs			= vxfs_statfs,
	.remount_fs		= vxfs_remount,
};
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197

static int vxfs_try_sb_magic(struct super_block *sbp, int silent,
		unsigned blk, __fs32 magic)
{
	struct buffer_head *bp;
	struct vxfs_sb *rsbp;
	struct vxfs_sb_info *infp = VXFS_SBI(sbp);
	int rc = -ENOMEM;

	bp = sb_bread(sbp, blk);
	do {
		if (!bp || !buffer_mapped(bp)) {
			if (!silent) {
				printk(KERN_WARNING
					"vxfs: unable to read disk superblock at %u\n",
					blk);
			}
			break;
		}

		rc = -EINVAL;
		rsbp = (struct vxfs_sb *)bp->b_data;
		if (rsbp->vs_magic != magic) {
			if (!silent)
				printk(KERN_NOTICE
					"vxfs: WRONG superblock magic %08x at %u\n",
					rsbp->vs_magic, blk);
			break;
		}

		rc = 0;
		infp->vsi_raw = rsbp;
		infp->vsi_bp = bp;
	} while (0);

	if (rc) {
		infp->vsi_raw = NULL;
		infp->vsi_bp = NULL;
		brelse(bp);
	}

	return rc;
}

Linus Torvalds's avatar
Linus Torvalds committed
198
/**
199
 * vxfs_read_super - read superblock into memory and initialize filesystem
Linus Torvalds's avatar
Linus Torvalds committed
200 201 202 203 204 205 206 207 208 209 210 211
 * @sbp:		VFS superblock (to fill)
 * @dp:			fs private mount data
 * @silent:		do not complain loudly when sth is wrong
 *
 * Description:
 *   We are called on the first mount of a filesystem to read the
 *   superblock into memory and do some basic setup.
 *
 * Returns:
 *   The superblock on success, else %NULL.
 *
 * Locking:
212
 *   We are under @sbp->s_lock.
Linus Torvalds's avatar
Linus Torvalds committed
213 214 215 216 217 218 219
 */
static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent)
{
	struct vxfs_sb_info	*infp;
	struct vxfs_sb		*rsbp;
	u_long			bsize;
	struct inode *root;
220
	int ret = -EINVAL;
221
	u32 j;
Linus Torvalds's avatar
Linus Torvalds committed
222 223 224

	sbp->s_flags |= MS_RDONLY;

225
	infp = kzalloc(sizeof(*infp), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
226 227 228 229 230 231 232 233 234 235 236
	if (!infp) {
		printk(KERN_WARNING "vxfs: unable to allocate incore superblock\n");
		return -ENOMEM;
	}

	bsize = sb_min_blocksize(sbp, BLOCK_SIZE);
	if (!bsize) {
		printk(KERN_WARNING "vxfs: unable to set blocksize\n");
		goto out;
	}

237
	sbp->s_op = &vxfs_super_ops;
238
	sbp->s_fs_info = infp;
Linus Torvalds's avatar
Linus Torvalds committed
239

240 241 242 243 244 245 246 247 248
	if (!vxfs_try_sb_magic(sbp, silent, 1,
			(__force __fs32)cpu_to_le32(VXFS_SUPER_MAGIC))) {
		/* Unixware, x86 */
		infp->byte_order = VXFS_BO_LE;
	} else if (!vxfs_try_sb_magic(sbp, silent, 8,
			(__force __fs32)cpu_to_be32(VXFS_SUPER_MAGIC))) {
		/* HP-UX, parisc */
		infp->byte_order = VXFS_BO_BE;
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
249
		if (!silent)
250
			printk(KERN_NOTICE "vxfs: can't find superblock.\n");
Linus Torvalds's avatar
Linus Torvalds committed
251 252 253
		goto out;
	}

254 255 256 257
	rsbp = infp->vsi_raw;
	j = fs32_to_cpu(infp, rsbp->vs_version);
	if ((j < 2 || j > 4) && !silent) {
		printk(KERN_NOTICE "vxfs: unsupported VxFS version (%d)\n", j);
Linus Torvalds's avatar
Linus Torvalds committed
258 259 260 261
		goto out;
	}

#ifdef DIAGNOSTIC
262 263 264
	printk(KERN_DEBUG "vxfs: supported VxFS version (%d)\n", j);
	printk(KERN_DEBUG "vxfs: blocksize: %d\n",
		fs32_to_cpu(infp, rsbp->vs_bsize));
Linus Torvalds's avatar
Linus Torvalds committed
265 266
#endif

267
	sbp->s_magic = fs32_to_cpu(infp, rsbp->vs_magic);
Linus Torvalds's avatar
Linus Torvalds committed
268

269 270
	infp->vsi_oltext = fs32_to_cpu(infp, rsbp->vs_oltext[0]);
	infp->vsi_oltsize = fs32_to_cpu(infp, rsbp->vs_oltsize);
Linus Torvalds's avatar
Linus Torvalds committed
271

272 273
	j = fs32_to_cpu(infp, rsbp->vs_bsize);
	if (!sb_set_blocksize(sbp, j)) {
Linus Torvalds's avatar
Linus Torvalds committed
274 275 276 277 278 279 280 281 282 283 284 285 286 287
		printk(KERN_WARNING "vxfs: unable to set final block size\n");
		goto out;
	}

	if (vxfs_read_olt(sbp, bsize)) {
		printk(KERN_WARNING "vxfs: unable to read olt\n");
		goto out;
	}

	if (vxfs_read_fshead(sbp)) {
		printk(KERN_WARNING "vxfs: unable to read fshead\n");
		goto out;
	}

288 289 290 291 292
	root = vxfs_iget(sbp, VXFS_ROOT_INO);
	if (IS_ERR(root)) {
		ret = PTR_ERR(root);
		goto out;
	}
293
	sbp->s_root = d_make_root(root);
Linus Torvalds's avatar
Linus Torvalds committed
294 295 296 297 298 299 300 301
	if (!sbp->s_root) {
		printk(KERN_WARNING "vxfs: unable to get root dentry.\n");
		goto out_free_ilist;
	}

	return 0;
	
out_free_ilist:
302 303 304
	iput(infp->vsi_fship);
	iput(infp->vsi_ilist);
	iput(infp->vsi_stilist);
Linus Torvalds's avatar
Linus Torvalds committed
305
out:
306
	brelse(infp->vsi_bp);
Linus Torvalds's avatar
Linus Torvalds committed
307
	kfree(infp);
308
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
309 310 311 312 313
}

/*
 * The usual module blurb.
 */
Al Viro's avatar
Al Viro committed
314 315
static struct dentry *vxfs_mount(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
316
{
Al Viro's avatar
Al Viro committed
317
	return mount_bdev(fs_type, flags, dev_name, data, vxfs_fill_super);
Linus Torvalds's avatar
Linus Torvalds committed
318 319 320 321 322
}

static struct file_system_type vxfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "vxfs",
Al Viro's avatar
Al Viro committed
323
	.mount		= vxfs_mount,
Linus Torvalds's avatar
Linus Torvalds committed
324 325 326
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
};
327
MODULE_ALIAS_FS("vxfs"); /* makes mount -t vxfs autoload the module */
328
MODULE_ALIAS("vxfs");
Linus Torvalds's avatar
Linus Torvalds committed
329 330 331 332

static int __init
vxfs_init(void)
{
333 334
	int rv;

Linus Torvalds's avatar
Linus Torvalds committed
335
	vxfs_inode_cachep = kmem_cache_create("vxfs_inode",
336 337
			sizeof(struct vxfs_inode_info), 0,
			SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL);
338 339 340 341 342 343
	if (!vxfs_inode_cachep)
		return -ENOMEM;
	rv = register_filesystem(&vxfs_fs_type);
	if (rv < 0)
		kmem_cache_destroy(vxfs_inode_cachep);
	return rv;
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346 347 348 349
}

static void __exit
vxfs_cleanup(void)
{
	unregister_filesystem(&vxfs_fs_type);
350 351 352 353 354
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
Linus Torvalds's avatar
Linus Torvalds committed
355 356 357 358 359
	kmem_cache_destroy(vxfs_inode_cachep);
}

module_init(vxfs_init);
module_exit(vxfs_cleanup);