[mirror_ubuntu-artful-kernel.git] / fs / xfs / libxfs / xfs_symlink_remote.c

/*
 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * Copyright (c) 2012-2013 Red Hat, Inc.
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_shared.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
#include "xfs_inode.h"
#include "xfs_error.h"
#include "xfs_trace.h"
#include "xfs_symlink.h"
#include "xfs_cksum.h"
#include "xfs_trans.h"
#include "xfs_buf_item.h"


/*
 * Each contiguous block has a header, so it is not just a simple pathlen
 * to FSB conversion.
 */
int
xfs_symlink_blocks(
	struct xfs_mount *mp,
	int		pathlen)
{
	int buflen = XFS_SYMLINK_BUF_SPACE(mp, mp->m_sb.sb_blocksize);

	return (pathlen + buflen - 1) / buflen;
}

int
xfs_symlink_hdr_set(
	struct xfs_mount	*mp,
	xfs_ino_t		ino,
	uint32_t		offset,
	uint32_t		size,
	struct xfs_buf		*bp)
{
	struct xfs_dsymlink_hdr	*dsl = bp->b_addr;

	if (!xfs_sb_version_hascrc(&mp->m_sb))
		return 0;

	dsl->sl_magic = cpu_to_be32(XFS_SYMLINK_MAGIC);
	dsl->sl_offset = cpu_to_be32(offset);
	dsl->sl_bytes = cpu_to_be32(size);
	uuid_copy(&dsl->sl_uuid, &mp->m_sb.sb_uuid);
	dsl->sl_owner = cpu_to_be64(ino);
	dsl->sl_blkno = cpu_to_be64(bp->b_bn);
	bp->b_ops = &xfs_symlink_buf_ops;

	return sizeof(struct xfs_dsymlink_hdr);
}

/*
 * Checking of the symlink header is split into two parts. the verifier does
 * CRC, location and bounds checking, the unpacking function checks the path
 * parameters and owner.
 */
bool
xfs_symlink_hdr_ok(
	xfs_ino_t		ino,
	uint32_t		offset,
	uint32_t		size,
	struct xfs_buf		*bp)
{
	struct xfs_dsymlink_hdr *dsl = bp->b_addr;

	if (offset != be32_to_cpu(dsl->sl_offset))
		return false;
	if (size != be32_to_cpu(dsl->sl_bytes))
		return false;
	if (ino != be64_to_cpu(dsl->sl_owner))
		return false;

	/* ok */
	return true;
}

static bool
xfs_symlink_verify(
	struct xfs_buf		*bp)
{
	struct xfs_mount	*mp = bp->b_target->bt_mount;
	struct xfs_dsymlink_hdr	*dsl = bp->b_addr;

	if (!xfs_sb_version_hascrc(&mp->m_sb))
		return false;
	if (dsl->sl_magic != cpu_to_be32(XFS_SYMLINK_MAGIC))
		return false;
	if (!uuid_equal(&dsl->sl_uuid, &mp->m_sb.sb_uuid))
		return false;
	if (bp->b_bn != be64_to_cpu(dsl->sl_blkno))
		return false;
	if (be32_to_cpu(dsl->sl_offset) +
				be32_to_cpu(dsl->sl_bytes) >= MAXPATHLEN)
		return false;
	if (dsl->sl_owner == 0)
		return false;

	return true;
}

static void
xfs_symlink_read_verify(
	struct xfs_buf	*bp)
{
	struct xfs_mount *mp = bp->b_target->bt_mount;

	/* no verification of non-crc buffers */
	if (!xfs_sb_version_hascrc(&mp->m_sb))
		return;

	if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF))
		xfs_buf_ioerror(bp, -EFSBADCRC);
	else if (!xfs_symlink_verify(bp))
		xfs_buf_ioerror(bp, -EFSCORRUPTED);

	if (bp->b_error)
		xfs_verifier_error(bp);
}

static void
xfs_symlink_write_verify(
	struct xfs_buf	*bp)
{
	struct xfs_mount *mp = bp->b_target->bt_mount;
	struct xfs_buf_log_item	*bip = bp->b_fspriv;

	/* no verification of non-crc buffers */
	if (!xfs_sb_version_hascrc(&mp->m_sb))
		return;

	if (!xfs_symlink_verify(bp)) {
		xfs_buf_ioerror(bp, -EFSCORRUPTED);
		xfs_verifier_error(bp);
		return;
	}

	if (bip) {
		struct xfs_dsymlink_hdr *dsl = bp->b_addr;
		dsl->sl_lsn = cpu_to_be64(bip->bli_item.li_lsn);
	}
	xfs_buf_update_cksum(bp, XFS_SYMLINK_CRC_OFF);
}

const struct xfs_buf_ops xfs_symlink_buf_ops = {
	.verify_read = xfs_symlink_read_verify,
	.verify_write = xfs_symlink_write_verify,
};

void
xfs_symlink_local_to_remote(
	struct xfs_trans	*tp,
	struct xfs_buf		*bp,
	struct xfs_inode	*ip,
	struct xfs_ifork	*ifp)
{
	struct xfs_mount	*mp = ip->i_mount;
	char			*buf;

	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SYMLINK_BUF);

	if (!xfs_sb_version_hascrc(&mp->m_sb)) {
		bp->b_ops = NULL;
		memcpy(bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes);
		return;
	}

	/*
	 * As this symlink fits in an inode literal area, it must also fit in
	 * the smallest buffer the filesystem supports.
	 */
	ASSERT(BBTOB(bp->b_length) >=
			ifp->if_bytes + sizeof(struct xfs_dsymlink_hdr));

	bp->b_ops = &xfs_symlink_buf_ops;

	buf = bp->b_addr;
	buf += xfs_symlink_hdr_set(mp, ip->i_ino, 0, ifp->if_bytes, bp);
	memcpy(buf, ifp->if_u1.if_data, ifp->if_bytes);
}
Commit	Line	Data
1fb7e48d DC	1	/*
	2	* Copyright (c) 2000-2006 Silicon Graphics, Inc.
	3	* Copyright (c) 2012-2013 Red Hat, Inc.
	4	* All rights reserved.
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License as
	8	* published by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope that it would be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write the Free Software Foundation,
	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18	*/
	19	#include "xfs.h"
	20	#include "xfs_fs.h"
	21	#include "xfs_format.h"
239880ef	22	#include "xfs_log_format.h"
70a9883c	23	#include "xfs_shared.h"
239880ef	24	#include "xfs_trans_resv.h"
1fb7e48d DC	25	#include "xfs_mount.h"
	26	#include "xfs_bmap_btree.h"
	27	#include "xfs_inode.h"
	28	#include "xfs_error.h"
	29	#include "xfs_trace.h"
	30	#include "xfs_symlink.h"
	31	#include "xfs_cksum.h"
239880ef	32	#include "xfs_trans.h"
1fb7e48d DC	33	#include "xfs_buf_item.h"
	34
	35
	36	/*
	37	* Each contiguous block has a header, so it is not just a simple pathlen
	38	* to FSB conversion.
	39	*/
	40	int
	41	xfs_symlink_blocks(
	42	struct xfs_mount *mp,
	43	int pathlen)
	44	{
	45	int buflen = XFS_SYMLINK_BUF_SPACE(mp, mp->m_sb.sb_blocksize);
	46
	47	return (pathlen + buflen - 1) / buflen;
	48	}
	49
	50	int
	51	xfs_symlink_hdr_set(
	52	struct xfs_mount *mp,
	53	xfs_ino_t ino,
	54	uint32_t offset,
	55	uint32_t size,
	56	struct xfs_buf *bp)
	57	{
	58	struct xfs_dsymlink_hdr *dsl = bp->b_addr;
	59
	60	if (!xfs_sb_version_hascrc(&mp->m_sb))
	61	return 0;
	62
	63	dsl->sl_magic = cpu_to_be32(XFS_SYMLINK_MAGIC);
	64	dsl->sl_offset = cpu_to_be32(offset);
	65	dsl->sl_bytes = cpu_to_be32(size);
	66	uuid_copy(&dsl->sl_uuid, &mp->m_sb.sb_uuid);
	67	dsl->sl_owner = cpu_to_be64(ino);
	68	dsl->sl_blkno = cpu_to_be64(bp->b_bn);
	69	bp->b_ops = &xfs_symlink_buf_ops;
	70
	71	return sizeof(struct xfs_dsymlink_hdr);
	72	}
	73
	74	/*
	75	* Checking of the symlink header is split into two parts. the verifier does
	76	* CRC, location and bounds checking, the unpacking function checks the path
	77	* parameters and owner.
	78	*/
	79	bool
	80	xfs_symlink_hdr_ok(
1fb7e48d DC	81	xfs_ino_t ino,
	82	uint32_t offset,
	83	uint32_t size,
	84	struct xfs_buf *bp)
	85	{
	86	struct xfs_dsymlink_hdr *dsl = bp->b_addr;
	87
	88	if (offset != be32_to_cpu(dsl->sl_offset))
	89	return false;
	90	if (size != be32_to_cpu(dsl->sl_bytes))
	91	return false;
	92	if (ino != be64_to_cpu(dsl->sl_owner))
	93	return false;
	94
	95	/* ok */
	96	return true;
	97	}
	98
	99	static bool
	100	xfs_symlink_verify(
	101	struct xfs_buf *bp)
	102	{
	103	struct xfs_mount *mp = bp->b_target->bt_mount;
	104	struct xfs_dsymlink_hdr *dsl = bp->b_addr;
	105
	106	if (!xfs_sb_version_hascrc(&mp->m_sb))
	107	return false;
	108	if (dsl->sl_magic != cpu_to_be32(XFS_SYMLINK_MAGIC))
	109	return false;
	110	if (!uuid_equal(&dsl->sl_uuid, &mp->m_sb.sb_uuid))
	111	return false;
	112	if (bp->b_bn != be64_to_cpu(dsl->sl_blkno))
	113	return false;
	114	if (be32_to_cpu(dsl->sl_offset) +
	115	be32_to_cpu(dsl->sl_bytes) >= MAXPATHLEN)
	116	return false;
	117	if (dsl->sl_owner == 0)
	118	return false;
	119
	120	return true;
	121	}
	122
	123	static void
	124	xfs_symlink_read_verify(
	125	struct xfs_buf *bp)
	126	{
	127	struct xfs_mount *mp = bp->b_target->bt_mount;
	128
	129	/* no verification of non-crc buffers */
	130	if (!xfs_sb_version_hascrc(&mp->m_sb))
	131	return;
	132
ce5028cf	133	if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF))
2451337d	134	xfs_buf_ioerror(bp, -EFSBADCRC);
ce5028cf	135	else if (!xfs_symlink_verify(bp))
2451337d	136	xfs_buf_ioerror(bp, -EFSCORRUPTED);
ce5028cf ES	137
	138	if (bp->b_error)
	139	xfs_verifier_error(bp);
1fb7e48d DC	140	}
	141
	142	static void
	143	xfs_symlink_write_verify(
	144	struct xfs_buf *bp)
	145	{
	146	struct xfs_mount *mp = bp->b_target->bt_mount;
	147	struct xfs_buf_log_item *bip = bp->b_fspriv;
	148
	149	/* no verification of non-crc buffers */
	150	if (!xfs_sb_version_hascrc(&mp->m_sb))
	151	return;
	152
	153	if (!xfs_symlink_verify(bp)) {
2451337d	154	xfs_buf_ioerror(bp, -EFSCORRUPTED);
ce5028cf	155	xfs_verifier_error(bp);
1fb7e48d DC	156	return;
	157	}
	158
	159	if (bip) {
	160	struct xfs_dsymlink_hdr *dsl = bp->b_addr;
	161	dsl->sl_lsn = cpu_to_be64(bip->bli_item.li_lsn);
	162	}
f1dbcd7e	163	xfs_buf_update_cksum(bp, XFS_SYMLINK_CRC_OFF);
1fb7e48d DC	164	}
	165
	166	const struct xfs_buf_ops xfs_symlink_buf_ops = {
	167	.verify_read = xfs_symlink_read_verify,
	168	.verify_write = xfs_symlink_write_verify,
	169	};
	170
	171	void
	172	xfs_symlink_local_to_remote(
	173	struct xfs_trans *tp,
	174	struct xfs_buf *bp,
	175	struct xfs_inode *ip,
	176	struct xfs_ifork *ifp)
	177	{
	178	struct xfs_mount *mp = ip->i_mount;
	179	char *buf;
	180
fe22d552 DC	181	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SYMLINK_BUF);
fe22d552 DC	182
1fb7e48d DC	183	if (!xfs_sb_version_hascrc(&mp->m_sb)) {
	184	bp->b_ops = NULL;
	185	memcpy(bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes);
	186	return;
	187	}
	188
	189	/*
	190	* As this symlink fits in an inode literal area, it must also fit in
	191	* the smallest buffer the filesystem supports.
	192	*/
	193	ASSERT(BBTOB(bp->b_length) >=
	194	ifp->if_bytes + sizeof(struct xfs_dsymlink_hdr));
	195
	196	bp->b_ops = &xfs_symlink_buf_ops;
	197
	198	buf = bp->b_addr;
	199	buf += xfs_symlink_hdr_set(mp, ip->i_ino, 0, ifp->if_bytes, bp);
	200	memcpy(buf, ifp->if_u1.if_data, ifp->if_bytes);
	201	}