[mirror_ubuntu-bionic-kernel.git] / fs / freevxfs / vxfs_bmap.c

/*
 * Copyright (c) 2000-2001 Christoph Hellwig.
 * 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 - filesystem to disk block mapping.
 */
#include <linux/fs.h>
#include <linux/buffer_head.h>
#include <linux/kernel.h>

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


#ifdef DIAGNOSTIC
static void
vxfs_typdump(struct vxfs_typed *typ)
{
	printk(KERN_DEBUG "type=%Lu ", typ->vt_hdr >> VXFS_TYPED_TYPESHIFT);
	printk("offset=%Lx ", typ->vt_hdr & VXFS_TYPED_OFFSETMASK);
	printk("block=%x ", typ->vt_block);
	printk("size=%x\n", typ->vt_size);
}
#endif

/**
 * vxfs_bmap_ext4 - do bmap for ext4 extents
 * @ip:		pointer to the inode we do bmap for
 * @iblock:	logical block.
 *
 * Description:
 *   vxfs_bmap_ext4 performs the bmap operation for inodes with
 *   ext4-style extents (which are much like the traditional UNIX
 *   inode organisation).
 *
 * Returns:
 *   The physical block number on success, else Zero.
 */
static daddr_t
vxfs_bmap_ext4(struct inode *ip, long bn)
{
	struct super_block *sb = ip->i_sb;
	struct vxfs_inode_info *vip = VXFS_INO(ip);
	struct vxfs_sb_info *sbi = VXFS_SBI(sb);
	unsigned long bsize = sb->s_blocksize;
	u32 indsize = fs32_to_cpu(sbi, vip->vii_ext4.ve4_indsize);
	int i;

	if (indsize > sb->s_blocksize)
		goto fail_size;

	for (i = 0; i < VXFS_NDADDR; i++) {
		struct direct *d = vip->vii_ext4.ve4_direct + i;
		if (bn >= 0 && bn < fs32_to_cpu(sbi, d->size))
			return (bn + fs32_to_cpu(sbi, d->extent));
		bn -= fs32_to_cpu(sbi, d->size);
	}

	if ((bn / (indsize * indsize * bsize / 4)) == 0) {
		struct buffer_head *buf;
		daddr_t	bno;
		__fs32 *indir;

		buf = sb_bread(sb,
			fs32_to_cpu(sbi, vip->vii_ext4.ve4_indir[0]));
		if (!buf || !buffer_mapped(buf))
			goto fail_buf;

		indir = (__fs32 *)buf->b_data;
		bno = fs32_to_cpu(sbi, indir[(bn / indsize) % (indsize * bn)]) +
			(bn % indsize);

		brelse(buf);
		return bno;
	} else
		printk(KERN_WARNING "no matching indir?");

	return 0;

fail_size:
	printk("vxfs: indirect extent too big!\n");
fail_buf:
	return 0;
}

/**
 * vxfs_bmap_indir - recursion for vxfs_bmap_typed
 * @ip:		pointer to the inode we do bmap for
 * @indir:	indirect block we start reading at
 * @size:	size of the typed area to search
 * @block:	partially result from further searches
 *
 * Description:
 *   vxfs_bmap_indir reads a &struct vxfs_typed at @indir
 *   and performs the type-defined action.
 *
 * Return Value:
 *   The physical block number on success, else Zero.
 *
 * Note:
 *   Kernelstack is rare.  Unrecurse?
 */
static daddr_t
vxfs_bmap_indir(struct inode *ip, long indir, int size, long block)
{
	struct vxfs_sb_info		*sbi = VXFS_SBI(ip->i_sb);
	struct buffer_head		*bp = NULL;
	daddr_t				pblock = 0;
	int				i;

	for (i = 0; i < size * VXFS_TYPED_PER_BLOCK(ip->i_sb); i++) {
		struct vxfs_typed	*typ;
		int64_t			off;

		bp = sb_bread(ip->i_sb,
				indir + (i / VXFS_TYPED_PER_BLOCK(ip->i_sb)));
		if (!bp || !buffer_mapped(bp))
			return 0;

		typ = ((struct vxfs_typed *)bp->b_data) +
			(i % VXFS_TYPED_PER_BLOCK(ip->i_sb));
		off = fs64_to_cpu(sbi, typ->vt_hdr) & VXFS_TYPED_OFFSETMASK;

		if (block < off) {
			brelse(bp);
			continue;
		}

		switch ((u_int32_t)(fs64_to_cpu(sbi, typ->vt_hdr) >>
				VXFS_TYPED_TYPESHIFT)) {
		case VXFS_TYPED_INDIRECT:
			pblock = vxfs_bmap_indir(ip,
					fs32_to_cpu(sbi, typ->vt_block),
					fs32_to_cpu(sbi, typ->vt_size),
					block - off);
			if (pblock == -2)
				break;
			goto out;
		case VXFS_TYPED_DATA:
			if ((block - off) >= fs32_to_cpu(sbi, typ->vt_size))
				break;
			pblock = fs32_to_cpu(sbi, typ->vt_block) + block - off;
			goto out;
		case VXFS_TYPED_INDIRECT_DEV4:
		case VXFS_TYPED_DATA_DEV4: {
			struct vxfs_typed_dev4	*typ4 =
				(struct vxfs_typed_dev4 *)typ;

			printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
			printk(KERN_INFO "block: %llu\tsize: %lld\tdev: %d\n",
			       fs64_to_cpu(sbi, typ4->vd4_block),
			       fs64_to_cpu(sbi, typ4->vd4_size),
			       fs32_to_cpu(sbi, typ4->vd4_dev));
			goto fail;
		}
		default:
			printk(KERN_ERR "%s:%d vt_hdr %llu\n", __func__,
				__LINE__, fs64_to_cpu(sbi, typ->vt_hdr));
			BUG();
		}
		brelse(bp);
	}

fail:
	pblock = 0;
out:
	brelse(bp);
	return (pblock);
}

/**
 * vxfs_bmap_typed - bmap for typed extents
 * @ip:		pointer to the inode we do bmap for
 * @iblock:	logical block
 *
 * Description:
 *   Performs the bmap operation for typed extents.
 *
 * Return Value:
 *   The physical block number on success, else Zero.
 */
static daddr_t
vxfs_bmap_typed(struct inode *ip, long iblock)
{
	struct vxfs_inode_info		*vip = VXFS_INO(ip);
	struct vxfs_sb_info		*sbi = VXFS_SBI(ip->i_sb);
	daddr_t				pblock = 0;
	int				i;

	for (i = 0; i < VXFS_NTYPED; i++) {
		struct vxfs_typed	*typ = vip->vii_org.typed + i;
		u64			hdr = fs64_to_cpu(sbi, typ->vt_hdr);
		int64_t			off = (hdr & VXFS_TYPED_OFFSETMASK);

#ifdef DIAGNOSTIC
		vxfs_typdump(typ);
#endif
		if (iblock < off)
			continue;
		switch ((u32)(hdr >> VXFS_TYPED_TYPESHIFT)) {
		case VXFS_TYPED_INDIRECT:
			pblock = vxfs_bmap_indir(ip,
					fs32_to_cpu(sbi, typ->vt_block),
					fs32_to_cpu(sbi, typ->vt_size),
					iblock - off);
			if (pblock == -2)
				break;
			return (pblock);
		case VXFS_TYPED_DATA:
			if ((iblock - off) < fs32_to_cpu(sbi, typ->vt_size))
				return (fs32_to_cpu(sbi, typ->vt_block) +
						iblock - off);
			break;
		case VXFS_TYPED_INDIRECT_DEV4:
		case VXFS_TYPED_DATA_DEV4: {
			struct vxfs_typed_dev4	*typ4 =
				(struct vxfs_typed_dev4 *)typ;

			printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
			printk(KERN_INFO "block: %llu\tsize: %lld\tdev: %d\n",
			       fs64_to_cpu(sbi, typ4->vd4_block),
			       fs64_to_cpu(sbi, typ4->vd4_size),
			       fs32_to_cpu(sbi, typ4->vd4_dev));
			return 0;
		}
		default:
			BUG();
		}
	}

	return 0;
}

/**
 * vxfs_bmap1 - vxfs-internal bmap operation
 * @ip:			pointer to the inode we do bmap for
 * @iblock:		logical block
 *
 * Description:
 *   vxfs_bmap1 perfoms a logical to physical block mapping
 *   for vxfs-internal purposes.
 *
 * Return Value:
 *   The physical block number on success, else Zero.
 */
daddr_t
vxfs_bmap1(struct inode *ip, long iblock)
{
	struct vxfs_inode_info		*vip = VXFS_INO(ip);

	if (VXFS_ISEXT4(vip))
		return vxfs_bmap_ext4(ip, iblock);
	if (VXFS_ISTYPED(vip))
		return vxfs_bmap_typed(ip, iblock);
	if (VXFS_ISNONE(vip))
		goto unsupp;
	if (VXFS_ISIMMED(vip))
		goto unsupp;

	printk(KERN_WARNING "vxfs: inode %ld has no valid orgtype (%x)\n",
			ip->i_ino, vip->vii_orgtype);
	BUG();

unsupp:
	printk(KERN_WARNING "vxfs: inode %ld has an unsupported orgtype (%x)\n",
			ip->i_ino, vip->vii_orgtype);
	return 0;
}
Commit	Line	Data
1da177e4 LT	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	/*
	31	* Veritas filesystem driver - filesystem to disk block mapping.
	32	*/
	33	#include <linux/fs.h>
	34	#include <linux/buffer_head.h>
	35	#include <linux/kernel.h>
	36
	37	#include "vxfs.h"
	38	#include "vxfs_inode.h"
6e1e8e11	39	#include "vxfs_extern.h"
1da177e4 LT	40
	41
	42	#ifdef DIAGNOSTIC
	43	static void
	44	vxfs_typdump(struct vxfs_typed *typ)
	45	{
	46	printk(KERN_DEBUG "type=%Lu ", typ->vt_hdr >> VXFS_TYPED_TYPESHIFT);
	47	printk("offset=%Lx ", typ->vt_hdr & VXFS_TYPED_OFFSETMASK);
	48	printk("block=%x ", typ->vt_block);
	49	printk("size=%x\n", typ->vt_size);
	50	}
	51	#endif
	52
	53	/**
	54	* vxfs_bmap_ext4 - do bmap for ext4 extents
	55	* @ip: pointer to the inode we do bmap for
	56	* @iblock: logical block.
	57	*
	58	* Description:
	59	* vxfs_bmap_ext4 performs the bmap operation for inodes with
	60	* ext4-style extents (which are much like the traditional UNIX
	61	* inode organisation).
	62	*
	63	* Returns:
	64	* The physical block number on success, else Zero.
	65	*/
	66	static daddr_t
	67	vxfs_bmap_ext4(struct inode *ip, long bn)
	68	{
	69	struct super_block *sb = ip->i_sb;
	70	struct vxfs_inode_info *vip = VXFS_INO(ip);
0d83f7fc	71	struct vxfs_sb_info *sbi = VXFS_SBI(sb);
1da177e4	72	unsigned long bsize = sb->s_blocksize;
0d83f7fc	73	u32 indsize = fs32_to_cpu(sbi, vip->vii_ext4.ve4_indsize);
1da177e4 LT	74	int i;
	75
	76	if (indsize > sb->s_blocksize)
	77	goto fail_size;
	78
	79	for (i = 0; i < VXFS_NDADDR; i++) {
	80	struct direct *d = vip->vii_ext4.ve4_direct + i;
0d83f7fc KB	81	if (bn >= 0 && bn < fs32_to_cpu(sbi, d->size))
	82	return (bn + fs32_to_cpu(sbi, d->extent));
	83	bn -= fs32_to_cpu(sbi, d->size);
1da177e4 LT	84	}
	85
	86	if ((bn / (indsize * indsize * bsize / 4)) == 0) {
	87	struct buffer_head *buf;
	88	daddr_t bno;
0d83f7fc	89	__fs32 *indir;
1da177e4	90
0d83f7fc KB	91	buf = sb_bread(sb,
0d83f7fc KB	92	fs32_to_cpu(sbi, vip->vii_ext4.ve4_indir[0]));
1da177e4 LT	93	if (!buf \|\| !buffer_mapped(buf))
	94	goto fail_buf;
	95
0d83f7fc KB	96	indir = (__fs32 *)buf->b_data;
	97	bno = fs32_to_cpu(sbi, indir[(bn / indsize) % (indsize * bn)]) +
	98	(bn % indsize);
1da177e4 LT	99
	100	brelse(buf);
	101	return bno;
	102	} else
	103	printk(KERN_WARNING "no matching indir?");
	104
	105	return 0;
	106
	107	fail_size:
8cb681b9	108	printk("vxfs: indirect extent too big!\n");
1da177e4 LT	109	fail_buf:
	110	return 0;
	111	}
	112
	113	/**
	114	* vxfs_bmap_indir - recursion for vxfs_bmap_typed
	115	* @ip: pointer to the inode we do bmap for
	116	* @indir: indirect block we start reading at
	117	* @size: size of the typed area to search
	118	* @block: partially result from further searches
	119	*
	120	* Description:
	121	* vxfs_bmap_indir reads a &struct vxfs_typed at @indir
	122	* and performs the type-defined action.
	123	*
	124	* Return Value:
	125	* The physical block number on success, else Zero.
	126	*
	127	* Note:
	128	* Kernelstack is rare. Unrecurse?
	129	*/
	130	static daddr_t
	131	vxfs_bmap_indir(struct inode *ip, long indir, int size, long block)
	132	{
0d83f7fc	133	struct vxfs_sb_info *sbi = VXFS_SBI(ip->i_sb);
1da177e4 LT	134	struct buffer_head *bp = NULL;
	135	daddr_t pblock = 0;
	136	int i;
	137
	138	for (i = 0; i < size * VXFS_TYPED_PER_BLOCK(ip->i_sb); i++) {
	139	struct vxfs_typed *typ;
	140	int64_t off;
	141
	142	bp = sb_bread(ip->i_sb,
	143	indir + (i / VXFS_TYPED_PER_BLOCK(ip->i_sb)));
82f703bb	144	if (!bp \|\| !buffer_mapped(bp))
1da177e4 LT	145	return 0;
	146
	147	typ = ((struct vxfs_typed *)bp->b_data) +
	148	(i % VXFS_TYPED_PER_BLOCK(ip->i_sb));
0d83f7fc	149	off = fs64_to_cpu(sbi, typ->vt_hdr) & VXFS_TYPED_OFFSETMASK;
1da177e4 LT	150
	151	if (block < off) {
	152	brelse(bp);
	153	continue;
	154	}
	155
0d83f7fc KB	156	switch ((u_int32_t)(fs64_to_cpu(sbi, typ->vt_hdr) >>
0d83f7fc KB	157	VXFS_TYPED_TYPESHIFT)) {
1da177e4	158	case VXFS_TYPED_INDIRECT:
0d83f7fc KB	159	pblock = vxfs_bmap_indir(ip,
	160	fs32_to_cpu(sbi, typ->vt_block),
	161	fs32_to_cpu(sbi, typ->vt_size),
	162	block - off);
1da177e4 LT	163	if (pblock == -2)
	164	break;
	165	goto out;
	166	case VXFS_TYPED_DATA:
0d83f7fc	167	if ((block - off) >= fs32_to_cpu(sbi, typ->vt_size))
1da177e4	168	break;
0d83f7fc	169	pblock = fs32_to_cpu(sbi, typ->vt_block) + block - off;
1da177e4 LT	170	goto out;
	171	case VXFS_TYPED_INDIRECT_DEV4:
	172	case VXFS_TYPED_DATA_DEV4: {
	173	struct vxfs_typed_dev4 *typ4 =
	174	(struct vxfs_typed_dev4 *)typ;
	175
	176	printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
0d83f7fc KB	177	printk(KERN_INFO "block: %llu\tsize: %lld\tdev: %d\n",
	178	fs64_to_cpu(sbi, typ4->vd4_block),
	179	fs64_to_cpu(sbi, typ4->vd4_size),
	180	fs32_to_cpu(sbi, typ4->vd4_dev));
1da177e4 LT	181	goto fail;
	182	}
	183	default:
0d83f7fc KB	184	printk(KERN_ERR "%s:%d vt_hdr %llu\n", __func__,
0d83f7fc KB	185	__LINE__, fs64_to_cpu(sbi, typ->vt_hdr));
1da177e4 LT	186	BUG();
	187	}
	188	brelse(bp);
	189	}
	190
	191	fail:
	192	pblock = 0;
	193	out:
	194	brelse(bp);
	195	return (pblock);
	196	}
	197
	198	/**
	199	* vxfs_bmap_typed - bmap for typed extents
	200	* @ip: pointer to the inode we do bmap for
	201	* @iblock: logical block
	202	*
	203	* Description:
	204	* Performs the bmap operation for typed extents.
	205	*
	206	* Return Value:
	207	* The physical block number on success, else Zero.
	208	*/
	209	static daddr_t
	210	vxfs_bmap_typed(struct inode *ip, long iblock)
	211	{
	212	struct vxfs_inode_info *vip = VXFS_INO(ip);
0d83f7fc	213	struct vxfs_sb_info *sbi = VXFS_SBI(ip->i_sb);
1da177e4 LT	214	daddr_t pblock = 0;
	215	int i;
	216
	217	for (i = 0; i < VXFS_NTYPED; i++) {
	218	struct vxfs_typed *typ = vip->vii_org.typed + i;
0d83f7fc KB	219	u64 hdr = fs64_to_cpu(sbi, typ->vt_hdr);
0d83f7fc KB	220	int64_t off = (hdr & VXFS_TYPED_OFFSETMASK);
1da177e4 LT	221
	222	#ifdef DIAGNOSTIC
	223	vxfs_typdump(typ);
	224	#endif
	225	if (iblock < off)
	226	continue;
0d83f7fc	227	switch ((u32)(hdr >> VXFS_TYPED_TYPESHIFT)) {
1da177e4	228	case VXFS_TYPED_INDIRECT:
0d83f7fc KB	229	pblock = vxfs_bmap_indir(ip,
	230	fs32_to_cpu(sbi, typ->vt_block),
	231	fs32_to_cpu(sbi, typ->vt_size),
	232	iblock - off);
1da177e4 LT	233	if (pblock == -2)
	234	break;
	235	return (pblock);
	236	case VXFS_TYPED_DATA:
0d83f7fc KB	237	if ((iblock - off) < fs32_to_cpu(sbi, typ->vt_size))
	238	return (fs32_to_cpu(sbi, typ->vt_block) +
	239	iblock - off);
1da177e4 LT	240	break;
	241	case VXFS_TYPED_INDIRECT_DEV4:
	242	case VXFS_TYPED_DATA_DEV4: {
	243	struct vxfs_typed_dev4 *typ4 =
	244	(struct vxfs_typed_dev4 *)typ;
	245
	246	printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
0d83f7fc KB	247	printk(KERN_INFO "block: %llu\tsize: %lld\tdev: %d\n",
	248	fs64_to_cpu(sbi, typ4->vd4_block),
	249	fs64_to_cpu(sbi, typ4->vd4_size),
	250	fs32_to_cpu(sbi, typ4->vd4_dev));
1da177e4 LT	251	return 0;
	252	}
	253	default:
	254	BUG();
	255	}
	256	}
	257
	258	return 0;
	259	}
	260
	261	/**
	262	* vxfs_bmap1 - vxfs-internal bmap operation
	263	* @ip: pointer to the inode we do bmap for
	264	* @iblock: logical block
	265	*
	266	* Description:
	267	* vxfs_bmap1 perfoms a logical to physical block mapping
	268	* for vxfs-internal purposes.
	269	*
	270	* Return Value:
	271	* The physical block number on success, else Zero.
	272	*/
	273	daddr_t
	274	vxfs_bmap1(struct inode *ip, long iblock)
	275	{
	276	struct vxfs_inode_info *vip = VXFS_INO(ip);
	277
	278	if (VXFS_ISEXT4(vip))
	279	return vxfs_bmap_ext4(ip, iblock);
	280	if (VXFS_ISTYPED(vip))
	281	return vxfs_bmap_typed(ip, iblock);
	282	if (VXFS_ISNONE(vip))
	283	goto unsupp;
	284	if (VXFS_ISIMMED(vip))
	285	goto unsupp;
	286
	287	printk(KERN_WARNING "vxfs: inode %ld has no valid orgtype (%x)\n",
	288	ip->i_ino, vip->vii_orgtype);
	289	BUG();
	290
	291	unsupp:
	292	printk(KERN_WARNING "vxfs: inode %ld has an unsupported orgtype (%x)\n",
	293	ip->i_ino, vip->vii_orgtype);
	294	return 0;
	295	}