[deliverable/linux.git] / fs / f2fs / acl.c

/*
 * fs/f2fs/acl.c
 *
 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
 *             http://www.samsung.com/
 *
 * Portions of this code from linux/fs/ext2/acl.c
 *
 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/f2fs_fs.h>
#include "f2fs.h"
#include "xattr.h"
#include "acl.h"

static inline size_t f2fs_acl_size(int count)
{
	if (count <= 4) {
		return sizeof(struct f2fs_acl_header) +
			count * sizeof(struct f2fs_acl_entry_short);
	} else {
		return sizeof(struct f2fs_acl_header) +
			4 * sizeof(struct f2fs_acl_entry_short) +
			(count - 4) * sizeof(struct f2fs_acl_entry);
	}
}

static inline int f2fs_acl_count(size_t size)
{
	ssize_t s;
	size -= sizeof(struct f2fs_acl_header);
	s = size - 4 * sizeof(struct f2fs_acl_entry_short);
	if (s < 0) {
		if (size % sizeof(struct f2fs_acl_entry_short))
			return -1;
		return size / sizeof(struct f2fs_acl_entry_short);
	} else {
		if (s % sizeof(struct f2fs_acl_entry))
			return -1;
		return s / sizeof(struct f2fs_acl_entry) + 4;
	}
}

static struct posix_acl *f2fs_acl_from_disk(const char *value, size_t size)
{
	int i, count;
	struct posix_acl *acl;
	struct f2fs_acl_header *hdr = (struct f2fs_acl_header *)value;
	struct f2fs_acl_entry *entry = (struct f2fs_acl_entry *)(hdr + 1);
	const char *end = value + size;

	if (hdr->a_version != cpu_to_le32(F2FS_ACL_VERSION))
		return ERR_PTR(-EINVAL);

	count = f2fs_acl_count(size);
	if (count < 0)
		return ERR_PTR(-EINVAL);
	if (count == 0)
		return NULL;

	acl = posix_acl_alloc(count, GFP_KERNEL);
	if (!acl)
		return ERR_PTR(-ENOMEM);

	for (i = 0; i < count; i++) {

		if ((char *)entry > end)
			goto fail;

		acl->a_entries[i].e_tag  = le16_to_cpu(entry->e_tag);
		acl->a_entries[i].e_perm = le16_to_cpu(entry->e_perm);

		switch (acl->a_entries[i].e_tag) {
		case ACL_USER_OBJ:
		case ACL_GROUP_OBJ:
		case ACL_MASK:
		case ACL_OTHER:
			entry = (struct f2fs_acl_entry *)((char *)entry +
					sizeof(struct f2fs_acl_entry_short));
			break;

		case ACL_USER:
			acl->a_entries[i].e_uid =
				make_kuid(&init_user_ns,
						le32_to_cpu(entry->e_id));
			entry = (struct f2fs_acl_entry *)((char *)entry +
					sizeof(struct f2fs_acl_entry));
			break;
		case ACL_GROUP:
			acl->a_entries[i].e_gid =
				make_kgid(&init_user_ns,
						le32_to_cpu(entry->e_id));
			entry = (struct f2fs_acl_entry *)((char *)entry +
					sizeof(struct f2fs_acl_entry));
			break;
		default:
			goto fail;
		}
	}
	if ((char *)entry != end)
		goto fail;
	return acl;
fail:
	posix_acl_release(acl);
	return ERR_PTR(-EINVAL);
}

static void *f2fs_acl_to_disk(const struct posix_acl *acl, size_t *size)
{
	struct f2fs_acl_header *f2fs_acl;
	struct f2fs_acl_entry *entry;
	int i;

	f2fs_acl = kmalloc(sizeof(struct f2fs_acl_header) + acl->a_count *
			sizeof(struct f2fs_acl_entry), GFP_KERNEL);
	if (!f2fs_acl)
		return ERR_PTR(-ENOMEM);

	f2fs_acl->a_version = cpu_to_le32(F2FS_ACL_VERSION);
	entry = (struct f2fs_acl_entry *)(f2fs_acl + 1);

	for (i = 0; i < acl->a_count; i++) {

		entry->e_tag  = cpu_to_le16(acl->a_entries[i].e_tag);
		entry->e_perm = cpu_to_le16(acl->a_entries[i].e_perm);

		switch (acl->a_entries[i].e_tag) {
		case ACL_USER:
			entry->e_id = cpu_to_le32(
					from_kuid(&init_user_ns,
						acl->a_entries[i].e_uid));
			entry = (struct f2fs_acl_entry *)((char *)entry +
					sizeof(struct f2fs_acl_entry));
			break;
		case ACL_GROUP:
			entry->e_id = cpu_to_le32(
					from_kgid(&init_user_ns,
						acl->a_entries[i].e_gid));
			entry = (struct f2fs_acl_entry *)((char *)entry +
					sizeof(struct f2fs_acl_entry));
			break;
		case ACL_USER_OBJ:
		case ACL_GROUP_OBJ:
		case ACL_MASK:
		case ACL_OTHER:
			entry = (struct f2fs_acl_entry *)((char *)entry +
					sizeof(struct f2fs_acl_entry_short));
			break;
		default:
			goto fail;
		}
	}
	*size = f2fs_acl_size(acl->a_count);
	return (void *)f2fs_acl;

fail:
	kfree(f2fs_acl);
	return ERR_PTR(-EINVAL);
}

struct posix_acl *f2fs_get_acl(struct inode *inode, int type)
{
	int name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT;
	void *value = NULL;
	struct posix_acl *acl;
	int retval;

	if (type == ACL_TYPE_ACCESS)
		name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;

	retval = f2fs_getxattr(inode, name_index, "", NULL, 0);
	if (retval > 0) {
		value = kmalloc(retval, GFP_F2FS_ZERO);
		if (!value)
			return ERR_PTR(-ENOMEM);
		retval = f2fs_getxattr(inode, name_index, "", value, retval);
	}

	if (retval > 0)
		acl = f2fs_acl_from_disk(value, retval);
	else if (retval == -ENODATA)
		acl = NULL;
	else
		acl = ERR_PTR(retval);
	kfree(value);

	if (!IS_ERR(acl))
		set_cached_acl(inode, type, acl);

	return acl;
}

static int __f2fs_set_acl(struct inode *inode, int type,
			struct posix_acl *acl, struct page *ipage)
{
	struct f2fs_inode_info *fi = F2FS_I(inode);
	int name_index;
	void *value = NULL;
	size_t size = 0;
	int error;

	if (acl) {
		error = posix_acl_valid(acl);
		if (error < 0)
			return error;
	}

	switch (type) {
	case ACL_TYPE_ACCESS:
		name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;
		if (acl) {
			error = posix_acl_equiv_mode(acl, &inode->i_mode);
			if (error < 0)
				return error;
			set_acl_inode(fi, inode->i_mode);
			if (error == 0)
				acl = NULL;
		}
		break;

	case ACL_TYPE_DEFAULT:
		name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT;
		if (!S_ISDIR(inode->i_mode))
			return acl ? -EACCES : 0;
		break;

	default:
		return -EINVAL;
	}

	if (acl) {
		value = f2fs_acl_to_disk(acl, &size);
		if (IS_ERR(value)) {
			cond_clear_inode_flag(fi, FI_ACL_MODE);
			return (int)PTR_ERR(value);
		}
	}

	error = f2fs_setxattr(inode, name_index, "", value, size, ipage, 0);

	kfree(value);
	if (!error)
		set_cached_acl(inode, type, acl);

	cond_clear_inode_flag(fi, FI_ACL_MODE);
	return error;
}

int f2fs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
{
	return __f2fs_set_acl(inode, type, acl, NULL);
}

int f2fs_init_acl(struct inode *inode, struct inode *dir, struct page *ipage)
{
	struct posix_acl *default_acl, *acl;
	int error = 0;

	error = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl);
	if (error)
		return error;

	if (default_acl) {
		error = __f2fs_set_acl(inode, ACL_TYPE_DEFAULT, default_acl,
				       ipage);
		posix_acl_release(default_acl);
	}
	if (acl) {
		if (error)
			error = __f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl,
					       ipage);
		posix_acl_release(acl);
	}

	return error;
}
Commit	Line	Data
0a8165d7	1	/*
af48b85b JK	2	* fs/f2fs/acl.c
	3	*
	4	* Copyright (c) 2012 Samsung Electronics Co., Ltd.
	5	* http://www.samsung.com/
	6	*
	7	* Portions of this code from linux/fs/ext2/acl.c
	8	*
	9	* Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License version 2 as
	13	* published by the Free Software Foundation.
	14	*/
	15	#include <linux/f2fs_fs.h>
	16	#include "f2fs.h"
	17	#include "xattr.h"
	18	#include "acl.h"
	19
af48b85b JK	20	static inline size_t f2fs_acl_size(int count)
	21	{
	22	if (count <= 4) {
	23	return sizeof(struct f2fs_acl_header) +
	24	count * sizeof(struct f2fs_acl_entry_short);
	25	} else {
	26	return sizeof(struct f2fs_acl_header) +
	27	4 * sizeof(struct f2fs_acl_entry_short) +
	28	(count - 4) * sizeof(struct f2fs_acl_entry);
	29	}
	30	}
	31
	32	static inline int f2fs_acl_count(size_t size)
	33	{
	34	ssize_t s;
	35	size -= sizeof(struct f2fs_acl_header);
	36	s = size - 4 * sizeof(struct f2fs_acl_entry_short);
	37	if (s < 0) {
	38	if (size % sizeof(struct f2fs_acl_entry_short))
	39	return -1;
	40	return size / sizeof(struct f2fs_acl_entry_short);
	41	} else {
	42	if (s % sizeof(struct f2fs_acl_entry))
	43	return -1;
	44	return s / sizeof(struct f2fs_acl_entry) + 4;
	45	}
	46	}
	47
	48	static struct posix_acl f2fs_acl_from_disk(const char value, size_t size)
	49	{
	50	int i, count;
	51	struct posix_acl *acl;
	52	struct f2fs_acl_header hdr = (struct f2fs_acl_header )value;
	53	struct f2fs_acl_entry entry = (struct f2fs_acl_entry )(hdr + 1);
	54	const char *end = value + size;
	55
	56	if (hdr->a_version != cpu_to_le32(F2FS_ACL_VERSION))
	57	return ERR_PTR(-EINVAL);
	58
	59	count = f2fs_acl_count(size);
	60	if (count < 0)
	61	return ERR_PTR(-EINVAL);
	62	if (count == 0)
	63	return NULL;
	64
	65	acl = posix_acl_alloc(count, GFP_KERNEL);
	66	if (!acl)
	67	return ERR_PTR(-ENOMEM);
	68
	69	for (i = 0; i < count; i++) {
	70
	71	if ((char *)entry > end)
	72	goto fail;
	73
	74	acl->a_entries[i].e_tag = le16_to_cpu(entry->e_tag);
	75	acl->a_entries[i].e_perm = le16_to_cpu(entry->e_perm);
	76
	77	switch (acl->a_entries[i].e_tag) {
	78	case ACL_USER_OBJ:
	79	case ACL_GROUP_OBJ:
	80	case ACL_MASK:
	81	case ACL_OTHER:
af48b85b JK	82	entry = (struct f2fs_acl_entry )((char )entry +
	83	sizeof(struct f2fs_acl_entry_short));
	84	break;
	85
	86	case ACL_USER:
	87	acl->a_entries[i].e_uid =
	88	make_kuid(&init_user_ns,
	89	le32_to_cpu(entry->e_id));
	90	entry = (struct f2fs_acl_entry )((char )entry +
	91	sizeof(struct f2fs_acl_entry));
	92	break;
	93	case ACL_GROUP:
	94	acl->a_entries[i].e_gid =
	95	make_kgid(&init_user_ns,
	96	le32_to_cpu(entry->e_id));
	97	entry = (struct f2fs_acl_entry )((char )entry +
	98	sizeof(struct f2fs_acl_entry));
	99	break;
	100	default:
	101	goto fail;
	102	}
	103	}
	104	if ((char *)entry != end)
	105	goto fail;
	106	return acl;
	107	fail:
	108	posix_acl_release(acl);
	109	return ERR_PTR(-EINVAL);
	110	}
	111
	112	static void f2fs_acl_to_disk(const struct posix_acl acl, size_t *size)
	113	{
	114	struct f2fs_acl_header *f2fs_acl;
	115	struct f2fs_acl_entry *entry;
	116	int i;
	117
	118	f2fs_acl = kmalloc(sizeof(struct f2fs_acl_header) + acl->a_count *
	119	sizeof(struct f2fs_acl_entry), GFP_KERNEL);
	120	if (!f2fs_acl)
	121	return ERR_PTR(-ENOMEM);
	122
	123	f2fs_acl->a_version = cpu_to_le32(F2FS_ACL_VERSION);
	124	entry = (struct f2fs_acl_entry *)(f2fs_acl + 1);
	125
	126	for (i = 0; i < acl->a_count; i++) {
	127
	128	entry->e_tag = cpu_to_le16(acl->a_entries[i].e_tag);
	129	entry->e_perm = cpu_to_le16(acl->a_entries[i].e_perm);
	130
	131	switch (acl->a_entries[i].e_tag) {
	132	case ACL_USER:
	133	entry->e_id = cpu_to_le32(
	134	from_kuid(&init_user_ns,
	135	acl->a_entries[i].e_uid));
	136	entry = (struct f2fs_acl_entry )((char )entry +
	137	sizeof(struct f2fs_acl_entry));
	138	break;
	139	case ACL_GROUP:
	140	entry->e_id = cpu_to_le32(
	141	from_kgid(&init_user_ns,
	142	acl->a_entries[i].e_gid));
	143	entry = (struct f2fs_acl_entry )((char )entry +
	144	sizeof(struct f2fs_acl_entry));
	145	break;
146	case ACL_USER_OBJ:
147	case ACL_GROUP_OBJ:
148	case ACL_MASK:
149	case ACL_OTHER:
150	entry = (struct f2fs_acl_entry )((char )entry +
151	sizeof(struct f2fs_acl_entry_short));
152	break;
153	default:
154	goto fail;
155	}
156	}
157	*size = f2fs_acl_size(acl->a_count);
158	return (void *)f2fs_acl;
159
160	fail:
161	kfree(f2fs_acl);
162	return ERR_PTR(-EINVAL);
163	}
164
165	struct posix_acl f2fs_get_acl(struct inode inode, int type)
166	{
af48b85b JK	167	int name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT;
	168	void *value = NULL;
	169	struct posix_acl *acl;
	170	int retval;
	171
af48b85b JK	172	if (type == ACL_TYPE_ACCESS)
	173	name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;
	174
	175	retval = f2fs_getxattr(inode, name_index, "", NULL, 0);
	176	if (retval > 0) {
808a1d74	177	value = kmalloc(retval, GFP_F2FS_ZERO);
af48b85b JK	178	if (!value)
	179	return ERR_PTR(-ENOMEM);
	180	retval = f2fs_getxattr(inode, name_index, "", value, retval);
	181	}
	182
c1b75eab	183	if (retval > 0)
af48b85b	184	acl = f2fs_acl_from_disk(value, retval);
c1b75eab JK	185	else if (retval == -ENODATA)
	186	acl = NULL;
	187	else
	188	acl = ERR_PTR(retval);
af48b85b	189	kfree(value);
c1b75eab	190
af48b85b JK	191	if (!IS_ERR(acl))
	192	set_cached_acl(inode, type, acl);
	193
	194	return acl;
	195	}
	196
a6dda0e6	197	static int __f2fs_set_acl(struct inode *inode, int type,
2ed2d5b3	198	struct posix_acl acl, struct page ipage)
af48b85b	199	{
af48b85b JK	200	struct f2fs_inode_info *fi = F2FS_I(inode);
	201	int name_index;
	202	void *value = NULL;
	203	size_t size = 0;
	204	int error;
	205
3a8861e2 Z	206	if (acl) {
	207	error = posix_acl_valid(acl);
	208	if (error < 0)
	209	return error;
	210	}
	211
af48b85b JK	212	switch (type) {
	213	case ACL_TYPE_ACCESS:
	214	name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;
	215	if (acl) {
	216	error = posix_acl_equiv_mode(acl, &inode->i_mode);
	217	if (error < 0)
	218	return error;
	219	set_acl_inode(fi, inode->i_mode);
	220	if (error == 0)
	221	acl = NULL;
	222	}
	223	break;
	224
	225	case ACL_TYPE_DEFAULT:
	226	name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT;
	227	if (!S_ISDIR(inode->i_mode))
	228	return acl ? -EACCES : 0;
	229	break;
	230
	231	default:
	232	return -EINVAL;
	233	}
	234
	235	if (acl) {
	236	value = f2fs_acl_to_disk(acl, &size);
	237	if (IS_ERR(value)) {
	238	cond_clear_inode_flag(fi, FI_ACL_MODE);
	239	return (int)PTR_ERR(value);
	240	}
	241	}
	242
c02745ef	243	error = f2fs_setxattr(inode, name_index, "", value, size, ipage, 0);
af48b85b JK	244
	245	kfree(value);
	246	if (!error)
	247	set_cached_acl(inode, type, acl);
	248
	249	cond_clear_inode_flag(fi, FI_ACL_MODE);
	250	return error;
	251	}
	252
a6dda0e6	253	int f2fs_set_acl(struct inode inode, struct posix_acl acl, int type)
af48b85b	254	{
a6dda0e6	255	return __f2fs_set_acl(inode, type, acl, NULL);
af48b85b JK	256	}
af48b85b JK	257
a6dda0e6	258	int f2fs_init_acl(struct inode inode, struct inode dir, struct page *ipage)
af48b85b	259	{
a6dda0e6 CH	260	struct posix_acl default_acl, acl;
a6dda0e6 CH	261	int error = 0;
af48b85b	262
a6dda0e6	263	error = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl);
af48b85b JK	264	if (error)
af48b85b JK	265	return error;
b8b60e1a	266
a6dda0e6 CH	267	if (default_acl) {
	268	error = __f2fs_set_acl(inode, ACL_TYPE_DEFAULT, default_acl,
	269	ipage);
	270	posix_acl_release(default_acl);
	271	}
	272	if (acl) {
	273	if (error)
	274	error = __f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl,
	275	ipage);
	276	posix_acl_release(acl);
af48b85b JK	277	}
af48b85b JK	278
af48b85b JK	279	return error;
af48b85b JK	280	}