[deliverable/linux.git] / fs / xfs / xfs_xattr.c

/*
 * Copyright (C) 2008 Christoph Hellwig.
 * Portions Copyright (C) 2000-2008 Silicon Graphics, Inc.
 *
 * 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_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"
#include "xfs_da_format.h"
#include "xfs_inode.h"
#include "xfs_attr.h"
#include "xfs_attr_leaf.h"
#include "xfs_acl.h"

#include <linux/posix_acl_xattr.h>
#include <linux/xattr.h>


static int
xfs_xattr_get(struct dentry *dentry, const char *name,
		void *value, size_t size, int xflags)
{
	struct xfs_inode *ip = XFS_I(d_inode(dentry));
	int error, asize = size;

	if (strcmp(name, "") == 0)
		return -EINVAL;

	/* Convert Linux syscall to XFS internal ATTR flags */
	if (!size) {
		xflags |= ATTR_KERNOVAL;
		value = NULL;
	}

	error = xfs_attr_get(ip, (unsigned char *)name, value, &asize, xflags);
	if (error)
		return error;
	return asize;
}

void
xfs_forget_acl(
	struct inode		*inode,
	const char		*name,
	int			xflags)
{
	/*
	 * Invalidate any cached ACLs if the user has bypassed the ACL
	 * interface. We don't validate the content whatsoever so it is caller
	 * responsibility to provide data in valid format and ensure i_mode is
	 * consistent.
	 */
	if (xflags & ATTR_ROOT) {
#ifdef CONFIG_XFS_POSIX_ACL
		if (!strcmp(name, SGI_ACL_FILE))
			forget_cached_acl(inode, ACL_TYPE_ACCESS);
		else if (!strcmp(name, SGI_ACL_DEFAULT))
			forget_cached_acl(inode, ACL_TYPE_DEFAULT);
#endif
	}
}

static int
xfs_xattr_set(struct dentry *dentry, const char *name, const void *value,
		size_t size, int flags, int xflags)
{
	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
	int			error;

	if (strcmp(name, "") == 0)
		return -EINVAL;

	/* Convert Linux syscall to XFS internal ATTR flags */
	if (flags & XATTR_CREATE)
		xflags |= ATTR_CREATE;
	if (flags & XATTR_REPLACE)
		xflags |= ATTR_REPLACE;

	if (!value)
		return xfs_attr_remove(ip, (unsigned char *)name, xflags);
	error = xfs_attr_set(ip, (unsigned char *)name,
				(void *)value, size, xflags);
	if (!error)
		xfs_forget_acl(d_inode(dentry), name, xflags);

	return error;
}

static const struct xattr_handler xfs_xattr_user_handler = {
	.prefix	= XATTR_USER_PREFIX,
	.flags	= 0, /* no flags implies user namespace */
	.get	= xfs_xattr_get,
	.set	= xfs_xattr_set,
};

static const struct xattr_handler xfs_xattr_trusted_handler = {
	.prefix	= XATTR_TRUSTED_PREFIX,
	.flags	= ATTR_ROOT,
	.get	= xfs_xattr_get,
	.set	= xfs_xattr_set,
};

static const struct xattr_handler xfs_xattr_security_handler = {
	.prefix	= XATTR_SECURITY_PREFIX,
	.flags	= ATTR_SECURE,
	.get	= xfs_xattr_get,
	.set	= xfs_xattr_set,
};

const struct xattr_handler *xfs_xattr_handlers[] = {
	&xfs_xattr_user_handler,
	&xfs_xattr_trusted_handler,
	&xfs_xattr_security_handler,
#ifdef CONFIG_XFS_POSIX_ACL
	&posix_acl_access_xattr_handler,
	&posix_acl_default_xattr_handler,
#endif
	NULL
};

static unsigned int xfs_xattr_prefix_len(int flags)
{
	if (flags & XFS_ATTR_SECURE)
		return sizeof("security");
	else if (flags & XFS_ATTR_ROOT)
		return sizeof("trusted");
	else
		return sizeof("user");
}

static const char *xfs_xattr_prefix(int flags)
{
	if (flags & XFS_ATTR_SECURE)
		return xfs_xattr_security_handler.prefix;
	else if (flags & XFS_ATTR_ROOT)
		return xfs_xattr_trusted_handler.prefix;
	else
		return xfs_xattr_user_handler.prefix;
}

static int
xfs_xattr_put_listent(
	struct xfs_attr_list_context *context,
	int		flags,
	unsigned char	*name,
	int		namelen,
	int		valuelen,
	unsigned char	*value)
{
	unsigned int prefix_len = xfs_xattr_prefix_len(flags);
	char *offset;
	int arraytop;

	ASSERT(context->count >= 0);

	/*
	 * Only show root namespace entries if we are actually allowed to
	 * see them.
	 */
	if ((flags & XFS_ATTR_ROOT) && !capable(CAP_SYS_ADMIN))
		return 0;

	arraytop = context->count + prefix_len + namelen + 1;
	if (arraytop > context->firstu) {
		context->count = -1;	/* insufficient space */
		return 1;
	}
	offset = (char *)context->alist + context->count;
	strncpy(offset, xfs_xattr_prefix(flags), prefix_len);
	offset += prefix_len;
	strncpy(offset, (char *)name, namelen);			/* real name */
	offset += namelen;
	*offset = '\0';
	context->count += prefix_len + namelen + 1;
	return 0;
}

static int
xfs_xattr_put_listent_sizes(
	struct xfs_attr_list_context *context,
	int		flags,
	unsigned char	*name,
	int		namelen,
	int		valuelen,
	unsigned char	*value)
{
	context->count += xfs_xattr_prefix_len(flags) + namelen + 1;
	return 0;
}

static int
list_one_attr(const char *name, const size_t len, void *data,
		size_t size, ssize_t *result)
{
	char *p = data + *result;

	*result += len;
	if (!size)
		return 0;
	if (*result > size)
		return -ERANGE;

	strcpy(p, name);
	return 0;
}

ssize_t
xfs_vn_listxattr(struct dentry *dentry, char *data, size_t size)
{
	struct xfs_attr_list_context context;
	struct attrlist_cursor_kern cursor = { 0 };
	struct inode		*inode = d_inode(dentry);
	int			error;

	/*
	 * First read the regular on-disk attributes.
	 */
	memset(&context, 0, sizeof(context));
	context.dp = XFS_I(inode);
	context.cursor = &cursor;
	context.resynch = 1;
	context.alist = data;
	context.bufsize = size;
	context.firstu = context.bufsize;

	if (size)
		context.put_listent = xfs_xattr_put_listent;
	else
		context.put_listent = xfs_xattr_put_listent_sizes;

	xfs_attr_list_int(&context);
	if (context.count < 0)
		return -ERANGE;

	/*
	 * Then add the two synthetic ACL attributes.
	 */
	if (posix_acl_access_exists(inode)) {
		error = list_one_attr(POSIX_ACL_XATTR_ACCESS,
				strlen(POSIX_ACL_XATTR_ACCESS) + 1,
				data, size, &context.count);
		if (error)
			return error;
	}

	if (posix_acl_default_exists(inode)) {
		error = list_one_attr(POSIX_ACL_XATTR_DEFAULT,
				strlen(POSIX_ACL_XATTR_DEFAULT) + 1,
				data, size, &context.count);
		if (error)
			return error;
	}

	return context.count;
}
Commit	Line	Data
f9e09f09 LM	1	/*
	2	* Copyright (C) 2008 Christoph Hellwig.
	3	* Portions Copyright (C) 2000-2008 Silicon Graphics, Inc.
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18
	19	#include "xfs.h"
a4fbe6ab	20	#include "xfs_format.h"
69432832	21	#include "xfs_log_format.h"
239880ef	22	#include "xfs_trans_resv.h"
57062787 DC	23	#include "xfs_mount.h"
57062787 DC	24	#include "xfs_da_format.h"
f9e09f09 LM	25	#include "xfs_inode.h"
	26	#include "xfs_attr.h"
	27	#include "xfs_attr_leaf.h"
	28	#include "xfs_acl.h"
f9e09f09 LM	29
	30	#include <linux/posix_acl_xattr.h>
	31	#include <linux/xattr.h>
	32
	33
f9e09f09	34	static int
431547b3	35	xfs_xattr_get(struct dentry dentry, const char name,
f9e09f09 LM	36	void *value, size_t size, int xflags)
f9e09f09 LM	37	{
2b0143b5	38	struct xfs_inode *ip = XFS_I(d_inode(dentry));
f9e09f09 LM	39	int error, asize = size;
	40
	41	if (strcmp(name, "") == 0)
	42	return -EINVAL;
	43
	44	/* Convert Linux syscall to XFS internal ATTR flags */
	45	if (!size) {
	46	xflags \|= ATTR_KERNOVAL;
	47	value = NULL;
	48	}
	49
2451337d	50	error = xfs_attr_get(ip, (unsigned char *)name, value, &asize, xflags);
f9e09f09 LM	51	if (error)
	52	return error;
	53	return asize;
	54	}
	55
47e1bf64 AG	56	void
	57	xfs_forget_acl(
	58	struct inode *inode,
	59	const char *name,
	60	int xflags)
	61	{
	62	/*
	63	* Invalidate any cached ACLs if the user has bypassed the ACL
	64	* interface. We don't validate the content whatsoever so it is caller
	65	* responsibility to provide data in valid format and ensure i_mode is
	66	* consistent.
	67	*/
	68	if (xflags & ATTR_ROOT) {
	69	#ifdef CONFIG_XFS_POSIX_ACL
	70	if (!strcmp(name, SGI_ACL_FILE))
	71	forget_cached_acl(inode, ACL_TYPE_ACCESS);
	72	else if (!strcmp(name, SGI_ACL_DEFAULT))
	73	forget_cached_acl(inode, ACL_TYPE_DEFAULT);
	74	#endif
	75	}
	76	}
	77
f9e09f09	78	static int
431547b3	79	xfs_xattr_set(struct dentry dentry, const char name, const void *value,
f9e09f09 LM	80	size_t size, int flags, int xflags)
f9e09f09 LM	81	{
67d8e04e BF	82	struct xfs_inode *ip = XFS_I(d_inode(dentry));
67d8e04e BF	83	int error;
f9e09f09 LM	84
	85	if (strcmp(name, "") == 0)
	86	return -EINVAL;
	87
	88	/* Convert Linux syscall to XFS internal ATTR flags */
	89	if (flags & XATTR_CREATE)
	90	xflags \|= ATTR_CREATE;
	91	if (flags & XATTR_REPLACE)
	92	xflags \|= ATTR_REPLACE;
	93
	94	if (!value)
2451337d	95	return xfs_attr_remove(ip, (unsigned char *)name, xflags);
67d8e04e	96	error = xfs_attr_set(ip, (unsigned char *)name,
a9273ca5	97	(void *)value, size, xflags);
47e1bf64 AG	98	if (!error)
47e1bf64 AG	99	xfs_forget_acl(d_inode(dentry), name, xflags);
67d8e04e BF	100
67d8e04e BF	101	return error;
f9e09f09 LM	102	}
f9e09f09 LM	103
46e58764	104	static const struct xattr_handler xfs_xattr_user_handler = {
f9e09f09	105	.prefix = XATTR_USER_PREFIX,
431547b3 CH	106	.flags = 0, /* no flags implies user namespace */
	107	.get = xfs_xattr_get,
	108	.set = xfs_xattr_set,
f9e09f09 LM	109	};
f9e09f09 LM	110
46e58764	111	static const struct xattr_handler xfs_xattr_trusted_handler = {
f9e09f09	112	.prefix = XATTR_TRUSTED_PREFIX,
431547b3 CH	113	.flags = ATTR_ROOT,
	114	.get = xfs_xattr_get,
	115	.set = xfs_xattr_set,
f9e09f09 LM	116	};
f9e09f09 LM	117
46e58764	118	static const struct xattr_handler xfs_xattr_security_handler = {
f9e09f09	119	.prefix = XATTR_SECURITY_PREFIX,
431547b3 CH	120	.flags = ATTR_SECURE,
	121	.get = xfs_xattr_get,
	122	.set = xfs_xattr_set,
f9e09f09 LM	123	};
f9e09f09 LM	124
46e58764	125	const struct xattr_handler *xfs_xattr_handlers[] = {
f9e09f09 LM	126	&xfs_xattr_user_handler,
	127	&xfs_xattr_trusted_handler,
	128	&xfs_xattr_security_handler,
ef14f0c1	129	#ifdef CONFIG_XFS_POSIX_ACL
2401dc29 CH	130	&posix_acl_access_xattr_handler,
2401dc29 CH	131	&posix_acl_default_xattr_handler,
ef14f0c1	132	#endif
f9e09f09 LM	133	NULL
	134	};
	135
	136	static unsigned int xfs_xattr_prefix_len(int flags)
	137	{
	138	if (flags & XFS_ATTR_SECURE)
	139	return sizeof("security");
	140	else if (flags & XFS_ATTR_ROOT)
	141	return sizeof("trusted");
	142	else
	143	return sizeof("user");
	144	}
	145
	146	static const char *xfs_xattr_prefix(int flags)
	147	{
	148	if (flags & XFS_ATTR_SECURE)
	149	return xfs_xattr_security_handler.prefix;
	150	else if (flags & XFS_ATTR_ROOT)
	151	return xfs_xattr_trusted_handler.prefix;
	152	else
	153	return xfs_xattr_user_handler.prefix;
	154	}
	155
	156	static int
a9273ca5 DC	157	xfs_xattr_put_listent(
	158	struct xfs_attr_list_context *context,
	159	int flags,
	160	unsigned char *name,
	161	int namelen,
	162	int valuelen,
	163	unsigned char *value)
f9e09f09 LM	164	{
	165	unsigned int prefix_len = xfs_xattr_prefix_len(flags);
	166	char *offset;
	167	int arraytop;
	168
	169	ASSERT(context->count >= 0);
	170
	171	/*
	172	* Only show root namespace entries if we are actually allowed to
	173	* see them.
	174	*/
	175	if ((flags & XFS_ATTR_ROOT) && !capable(CAP_SYS_ADMIN))
	176	return 0;
	177
	178	arraytop = context->count + prefix_len + namelen + 1;
	179	if (arraytop > context->firstu) {
	180	context->count = -1; /* insufficient space */
	181	return 1;
	182	}
	183	offset = (char *)context->alist + context->count;
	184	strncpy(offset, xfs_xattr_prefix(flags), prefix_len);
	185	offset += prefix_len;
a9273ca5	186	strncpy(offset, (char )name, namelen); / real name */
f9e09f09 LM	187	offset += namelen;
	188	*offset = '\0';
	189	context->count += prefix_len + namelen + 1;
	190	return 0;
	191	}
	192
	193	static int
a9273ca5 DC	194	xfs_xattr_put_listent_sizes(
	195	struct xfs_attr_list_context *context,
	196	int flags,
	197	unsigned char *name,
	198	int namelen,
	199	int valuelen,
	200	unsigned char *value)
f9e09f09 LM	201	{
	202	context->count += xfs_xattr_prefix_len(flags) + namelen + 1;
	203	return 0;
	204	}
	205
	206	static int
	207	list_one_attr(const char name, const size_t len, void data,
	208	size_t size, ssize_t *result)
	209	{
	210	char p = data + result;
	211
	212	*result += len;
	213	if (!size)
	214	return 0;
	215	if (*result > size)
	216	return -ERANGE;
	217
	218	strcpy(p, name);
	219	return 0;
	220	}
	221
	222	ssize_t
	223	xfs_vn_listxattr(struct dentry dentry, char data, size_t size)
	224	{
	225	struct xfs_attr_list_context context;
	226	struct attrlist_cursor_kern cursor = { 0 };
2b0143b5	227	struct inode *inode = d_inode(dentry);
f9e09f09 LM	228	int error;
	229
	230	/*
	231	* First read the regular on-disk attributes.
	232	*/
	233	memset(&context, 0, sizeof(context));
	234	context.dp = XFS_I(inode);
	235	context.cursor = &cursor;
	236	context.resynch = 1;
	237	context.alist = data;
	238	context.bufsize = size;
	239	context.firstu = context.bufsize;
	240
	241	if (size)
	242	context.put_listent = xfs_xattr_put_listent;
	243	else
	244	context.put_listent = xfs_xattr_put_listent_sizes;
	245
	246	xfs_attr_list_int(&context);
	247	if (context.count < 0)
	248	return -ERANGE;
	249
	250	/*
	251	* Then add the two synthetic ACL attributes.
	252	*/
ef14f0c1	253	if (posix_acl_access_exists(inode)) {
f9e09f09 LM	254	error = list_one_attr(POSIX_ACL_XATTR_ACCESS,
	255	strlen(POSIX_ACL_XATTR_ACCESS) + 1,
	256	data, size, &context.count);
	257	if (error)
	258	return error;
	259	}
	260
ef14f0c1	261	if (posix_acl_default_exists(inode)) {
f9e09f09 LM	262	error = list_one_attr(POSIX_ACL_XATTR_DEFAULT,
	263	strlen(POSIX_ACL_XATTR_DEFAULT) + 1,
	264	data, size, &context.count);
	265	if (error)
	266	return error;
	267	}
	268
	269	return context.count;
	270	}