[deliverable/linux.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"
#include "xfs_log.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;

	memset(dsl, 0, sizeof(struct xfs_dsymlink_hdr));
	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_meta_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_meta_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;
	if (!xfs_log_check_lsn(mp, be64_to_cpu(dsl->sl_lsn)))
		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 = {
	.name = "xfs_symlink",
	.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);
		xfs_trans_log_buf(tp, bp, 0, ifp->if_bytes - 1);
		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);
	xfs_trans_log_buf(tp, bp, 0, sizeof(struct xfs_dsymlink_hdr) +
					ifp->if_bytes - 1);
}
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	33	#include "xfs_buf_item.h"
a45086e2	34	#include "xfs_log.h"
1fb7e48d DC	35
	36
	37	/*
	38	* Each contiguous block has a header, so it is not just a simple pathlen
	39	* to FSB conversion.
	40	*/
	41	int
	42	xfs_symlink_blocks(
	43	struct xfs_mount *mp,
	44	int pathlen)
	45	{
	46	int buflen = XFS_SYMLINK_BUF_SPACE(mp, mp->m_sb.sb_blocksize);
	47
	48	return (pathlen + buflen - 1) / buflen;
	49	}
	50
	51	int
	52	xfs_symlink_hdr_set(
	53	struct xfs_mount *mp,
	54	xfs_ino_t ino,
	55	uint32_t offset,
	56	uint32_t size,
	57	struct xfs_buf *bp)
	58	{
	59	struct xfs_dsymlink_hdr *dsl = bp->b_addr;
	60
	61	if (!xfs_sb_version_hascrc(&mp->m_sb))
	62	return 0;
	63
a45086e2	64	memset(dsl, 0, sizeof(struct xfs_dsymlink_hdr));
1fb7e48d DC	65	dsl->sl_magic = cpu_to_be32(XFS_SYMLINK_MAGIC);
	66	dsl->sl_offset = cpu_to_be32(offset);
	67	dsl->sl_bytes = cpu_to_be32(size);
ce748eaa	68	uuid_copy(&dsl->sl_uuid, &mp->m_sb.sb_meta_uuid);
1fb7e48d DC	69	dsl->sl_owner = cpu_to_be64(ino);
	70	dsl->sl_blkno = cpu_to_be64(bp->b_bn);
	71	bp->b_ops = &xfs_symlink_buf_ops;
	72
	73	return sizeof(struct xfs_dsymlink_hdr);
	74	}
	75
	76	/*
	77	* Checking of the symlink header is split into two parts. the verifier does
	78	* CRC, location and bounds checking, the unpacking function checks the path
	79	* parameters and owner.
	80	*/
	81	bool
	82	xfs_symlink_hdr_ok(
1fb7e48d DC	83	xfs_ino_t ino,
	84	uint32_t offset,
	85	uint32_t size,
	86	struct xfs_buf *bp)
	87	{
	88	struct xfs_dsymlink_hdr *dsl = bp->b_addr;
	89
	90	if (offset != be32_to_cpu(dsl->sl_offset))
	91	return false;
	92	if (size != be32_to_cpu(dsl->sl_bytes))
	93	return false;
	94	if (ino != be64_to_cpu(dsl->sl_owner))
	95	return false;
	96
	97	/* ok */
	98	return true;
	99	}
	100
	101	static bool
	102	xfs_symlink_verify(
	103	struct xfs_buf *bp)
	104	{
	105	struct xfs_mount *mp = bp->b_target->bt_mount;
	106	struct xfs_dsymlink_hdr *dsl = bp->b_addr;
	107
	108	if (!xfs_sb_version_hascrc(&mp->m_sb))
	109	return false;
	110	if (dsl->sl_magic != cpu_to_be32(XFS_SYMLINK_MAGIC))
	111	return false;
ce748eaa	112	if (!uuid_equal(&dsl->sl_uuid, &mp->m_sb.sb_meta_uuid))
1fb7e48d DC	113	return false;
	114	if (bp->b_bn != be64_to_cpu(dsl->sl_blkno))
	115	return false;
	116	if (be32_to_cpu(dsl->sl_offset) +
	117	be32_to_cpu(dsl->sl_bytes) >= MAXPATHLEN)
	118	return false;
	119	if (dsl->sl_owner == 0)
	120	return false;
a45086e2 BF	121	if (!xfs_log_check_lsn(mp, be64_to_cpu(dsl->sl_lsn)))
a45086e2 BF	122	return false;
1fb7e48d DC	123
	124	return true;
	125	}
	126
	127	static void
	128	xfs_symlink_read_verify(
	129	struct xfs_buf *bp)
	130	{
	131	struct xfs_mount *mp = bp->b_target->bt_mount;
	132
	133	/* no verification of non-crc buffers */
	134	if (!xfs_sb_version_hascrc(&mp->m_sb))
	135	return;
	136
ce5028cf	137	if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF))
2451337d	138	xfs_buf_ioerror(bp, -EFSBADCRC);
ce5028cf	139	else if (!xfs_symlink_verify(bp))
2451337d	140	xfs_buf_ioerror(bp, -EFSCORRUPTED);
ce5028cf ES	141
	142	if (bp->b_error)
	143	xfs_verifier_error(bp);
1fb7e48d DC	144	}
	145
	146	static void
	147	xfs_symlink_write_verify(
	148	struct xfs_buf *bp)
	149	{
	150	struct xfs_mount *mp = bp->b_target->bt_mount;
	151	struct xfs_buf_log_item *bip = bp->b_fspriv;
	152
	153	/* no verification of non-crc buffers */
	154	if (!xfs_sb_version_hascrc(&mp->m_sb))
	155	return;
	156
	157	if (!xfs_symlink_verify(bp)) {
2451337d	158	xfs_buf_ioerror(bp, -EFSCORRUPTED);
ce5028cf	159	xfs_verifier_error(bp);
1fb7e48d DC	160	return;
	161	}
	162
	163	if (bip) {
	164	struct xfs_dsymlink_hdr *dsl = bp->b_addr;
	165	dsl->sl_lsn = cpu_to_be64(bip->bli_item.li_lsn);
	166	}
f1dbcd7e	167	xfs_buf_update_cksum(bp, XFS_SYMLINK_CRC_OFF);
1fb7e48d DC	168	}
	169
	170	const struct xfs_buf_ops xfs_symlink_buf_ops = {
233135b7	171	.name = "xfs_symlink",
1fb7e48d DC	172	.verify_read = xfs_symlink_read_verify,
	173	.verify_write = xfs_symlink_write_verify,
	174	};
	175
	176	void
	177	xfs_symlink_local_to_remote(
	178	struct xfs_trans *tp,
	179	struct xfs_buf *bp,
	180	struct xfs_inode *ip,
	181	struct xfs_ifork *ifp)
	182	{
	183	struct xfs_mount *mp = ip->i_mount;
	184	char *buf;
	185
fe22d552 DC	186	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SYMLINK_BUF);
fe22d552 DC	187
1fb7e48d DC	188	if (!xfs_sb_version_hascrc(&mp->m_sb)) {
	189	bp->b_ops = NULL;
	190	memcpy(bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes);
b7cdc66b	191	xfs_trans_log_buf(tp, bp, 0, ifp->if_bytes - 1);
1fb7e48d DC	192	return;
	193	}
	194
	195	/*
	196	* As this symlink fits in an inode literal area, it must also fit in
	197	* the smallest buffer the filesystem supports.
	198	*/
	199	ASSERT(BBTOB(bp->b_length) >=
	200	ifp->if_bytes + sizeof(struct xfs_dsymlink_hdr));
	201
	202	bp->b_ops = &xfs_symlink_buf_ops;
	203
	204	buf = bp->b_addr;
	205	buf += xfs_symlink_hdr_set(mp, ip->i_ino, 0, ifp->if_bytes, bp);
	206	memcpy(buf, ifp->if_u1.if_data, ifp->if_bytes);
b7cdc66b BF	207	xfs_trans_log_buf(tp, bp, 0, sizeof(struct xfs_dsymlink_hdr) +
b7cdc66b BF	208	ifp->if_bytes - 1);
1fb7e48d	209	}