[deliverable/linux.git] / fs / xfs / 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_shared.h"
#include "xfs_log.h"
#include "xfs_trans.h"
#include "xfs_ag.h"
#include "xfs_sb.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_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(
	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 (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_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
				  offsetof(struct xfs_dsymlink_hdr, sl_crc)) ||
	    !xfs_symlink_verify(bp)) {
		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
		xfs_buf_ioerror(bp, EFSCORRUPTED);
	}
}

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_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		return;
	}

	if (bip) {
		struct xfs_dsymlink_hdr *dsl = bp->b_addr;
		dsl->sl_lsn = cpu_to_be64(bip->bli_item.li_lsn);
	}
	xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length),
			 offsetof(struct xfs_dsymlink_hdr, sl_crc));
}

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;

	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"
70a9883c	22	#include "xfs_shared.h"
1fb7e48d DC	23	#include "xfs_log.h"
1fb7e48d DC	24	#include "xfs_trans.h"
9356fe22	25	#include "xfs_ag.h"
1fb7e48d DC	26	#include "xfs_sb.h"
	27	#include "xfs_mount.h"
	28	#include "xfs_bmap_btree.h"
	29	#include "xfs_inode.h"
	30	#include "xfs_error.h"
	31	#include "xfs_trace.h"
	32	#include "xfs_symlink.h"
	33	#include "xfs_cksum.h"
	34	#include "xfs_buf_item.h"
	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
	64	dsl->sl_magic = cpu_to_be32(XFS_SYMLINK_MAGIC);
	65	dsl->sl_offset = cpu_to_be32(offset);
	66	dsl->sl_bytes = cpu_to_be32(size);
	67	uuid_copy(&dsl->sl_uuid, &mp->m_sb.sb_uuid);
	68	dsl->sl_owner = cpu_to_be64(ino);
	69	dsl->sl_blkno = cpu_to_be64(bp->b_bn);
	70	bp->b_ops = &xfs_symlink_buf_ops;
	71
	72	return sizeof(struct xfs_dsymlink_hdr);
	73	}
	74
	75	/*
	76	* Checking of the symlink header is split into two parts. the verifier does
	77	* CRC, location and bounds checking, the unpacking function checks the path
	78	* parameters and owner.
	79	*/
	80	bool
	81	xfs_symlink_hdr_ok(
	82	struct xfs_mount *mp,
	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;
112	if (!uuid_equal(&dsl->sl_uuid, &mp->m_sb.sb_uuid))
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;
121
122	return true;
123	}
124
125	static void
126	xfs_symlink_read_verify(
127	struct xfs_buf *bp)
128	{
129	struct xfs_mount *mp = bp->b_target->bt_mount;
130
131	/* no verification of non-crc buffers */
132	if (!xfs_sb_version_hascrc(&mp->m_sb))
133	return;
134
135	if (!xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
136	offsetof(struct xfs_dsymlink_hdr, sl_crc)) \|\|
137	!xfs_symlink_verify(bp)) {
138	XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
139	xfs_buf_ioerror(bp, EFSCORRUPTED);
140	}
141	}
142
143	static void
144	xfs_symlink_write_verify(
145	struct xfs_buf *bp)
146	{
147	struct xfs_mount *mp = bp->b_target->bt_mount;
148	struct xfs_buf_log_item *bip = bp->b_fspriv;
149
150	/* no verification of non-crc buffers */
151	if (!xfs_sb_version_hascrc(&mp->m_sb))
152	return;
153
154	if (!xfs_symlink_verify(bp)) {
155	XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
156	xfs_buf_ioerror(bp, EFSCORRUPTED);
157	return;
158	}
159
160	if (bip) {
161	struct xfs_dsymlink_hdr *dsl = bp->b_addr;
162	dsl->sl_lsn = cpu_to_be64(bip->bli_item.li_lsn);
163	}
164	xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length),
165	offsetof(struct xfs_dsymlink_hdr, sl_crc));
166	}
167
168	const struct xfs_buf_ops xfs_symlink_buf_ops = {
169	.verify_read = xfs_symlink_read_verify,
170	.verify_write = xfs_symlink_write_verify,
171	};
172
173	void
174	xfs_symlink_local_to_remote(
175	struct xfs_trans *tp,
176	struct xfs_buf *bp,
177	struct xfs_inode *ip,
178	struct xfs_ifork *ifp)
179	{
180	struct xfs_mount *mp = ip->i_mount;
181	char *buf;
182
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	}