[linux-2.6-block.git] / fs / jfs / acl.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *   Copyright (C) International Business Machines  Corp., 2002-2004
 *   Copyright (C) Andreas Gruenbacher, 2001
 *   Copyright (C) Linus Torvalds, 1991, 1992
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/posix_acl_xattr.h>
#include "jfs_incore.h"
#include "jfs_txnmgr.h"
#include "jfs_xattr.h"
#include "jfs_acl.h"

struct posix_acl *jfs_get_acl(struct inode *inode, int type)
{
	struct posix_acl *acl;
	char *ea_name;
	int size;
	char *value = NULL;

	switch(type) {
		case ACL_TYPE_ACCESS:
			ea_name = XATTR_NAME_POSIX_ACL_ACCESS;
			break;
		case ACL_TYPE_DEFAULT:
			ea_name = XATTR_NAME_POSIX_ACL_DEFAULT;
			break;
		default:
			return ERR_PTR(-EINVAL);
	}

	size = __jfs_getxattr(inode, ea_name, NULL, 0);

	if (size > 0) {
		value = kmalloc(size, GFP_KERNEL);
		if (!value)
			return ERR_PTR(-ENOMEM);
		size = __jfs_getxattr(inode, ea_name, value, size);
	}

	if (size < 0) {
		if (size == -ENODATA)
			acl = NULL;
		else
			acl = ERR_PTR(size);
	} else {
		acl = posix_acl_from_xattr(&init_user_ns, value, size);
	}
	kfree(value);
	return acl;
}

static int __jfs_set_acl(tid_t tid, struct inode *inode, int type,
		       struct posix_acl *acl)
{
	char *ea_name;
	int rc;
	int size = 0;
	char *value = NULL;

	switch (type) {
	case ACL_TYPE_ACCESS:
		ea_name = XATTR_NAME_POSIX_ACL_ACCESS;
		break;
	case ACL_TYPE_DEFAULT:
		ea_name = XATTR_NAME_POSIX_ACL_DEFAULT;
		break;
	default:
		return -EINVAL;
	}

	if (acl) {
		size = posix_acl_xattr_size(acl->a_count);
		value = kmalloc(size, GFP_KERNEL);
		if (!value)
			return -ENOMEM;
		rc = posix_acl_to_xattr(&init_user_ns, acl, value, size);
		if (rc < 0)
			goto out;
	}
	rc = __jfs_setxattr(tid, inode, ea_name, value, size, 0);
out:
	kfree(value);

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

	return rc;
}

int jfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
{
	int rc;
	tid_t tid;
	int update_mode = 0;
	umode_t mode = inode->i_mode;

	tid = txBegin(inode->i_sb, 0);
	mutex_lock(&JFS_IP(inode)->commit_mutex);
	if (type == ACL_TYPE_ACCESS && acl) {
		rc = posix_acl_update_mode(inode, &mode, &acl);
		if (rc)
			goto end_tx;
		if (mode != inode->i_mode)
			update_mode = 1;
	}
	rc = __jfs_set_acl(tid, inode, type, acl);
	if (!rc) {
		if (update_mode) {
			inode->i_mode = mode;
			inode->i_ctime = current_time(inode);
			mark_inode_dirty(inode);
		}
		rc = txCommit(tid, 1, &inode, 0);
	}
end_tx:
	txEnd(tid);
	mutex_unlock(&JFS_IP(inode)->commit_mutex);
	return rc;
}

int jfs_init_acl(tid_t tid, struct inode *inode, struct inode *dir)
{
	struct posix_acl *default_acl, *acl;
	int rc = 0;

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

	if (default_acl) {
		rc = __jfs_set_acl(tid, inode, ACL_TYPE_DEFAULT, default_acl);
		posix_acl_release(default_acl);
	} else {
		inode->i_default_acl = NULL;
	}

	if (acl) {
		if (!rc)
			rc = __jfs_set_acl(tid, inode, ACL_TYPE_ACCESS, acl);
		posix_acl_release(acl);
	} else {
		inode->i_acl = NULL;
	}

	JFS_IP(inode)->mode2 = (JFS_IP(inode)->mode2 & 0xffff0000) |
			       inode->i_mode;

	return rc;
}
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
	3	* Copyright (C) International Business Machines Corp., 2002-2004
	4	* Copyright (C) Andreas Gruenbacher, 2001
	5	* Copyright (C) Linus Torvalds, 1991, 1992
1da177e4 LT	6	*/
	7
	8	#include <linux/sched.h>
5a0e3ad6	9	#include <linux/slab.h>
1da177e4	10	#include <linux/fs.h>
9a59f452	11	#include <linux/posix_acl_xattr.h>
1da177e4	12	#include "jfs_incore.h"
4f4b401b	13	#include "jfs_txnmgr.h"
1da177e4 LT	14	#include "jfs_xattr.h"
	15	#include "jfs_acl.h"
	16
4e34e719	17	struct posix_acl jfs_get_acl(struct inode inode, int type)
1da177e4 LT	18	{
	19	struct posix_acl *acl;
	20	char *ea_name;
1da177e4 LT	21	int size;
	22	char *value = NULL;
	23
	24	switch(type) {
	25	case ACL_TYPE_ACCESS:
97d79299	26	ea_name = XATTR_NAME_POSIX_ACL_ACCESS;
1da177e4 LT	27	break;
1da177e4 LT	28	case ACL_TYPE_DEFAULT:
97d79299	29	ea_name = XATTR_NAME_POSIX_ACL_DEFAULT;
1da177e4 LT	30	break;
	31	default:
	32	return ERR_PTR(-EINVAL);
	33	}
	34
1da177e4 LT	35	size = __jfs_getxattr(inode, ea_name, NULL, 0);
	36
	37	if (size > 0) {
	38	value = kmalloc(size, GFP_KERNEL);
	39	if (!value)
	40	return ERR_PTR(-ENOMEM);
	41	size = __jfs_getxattr(inode, ea_name, value, size);
	42	}
	43
	44	if (size < 0) {
073aaa1b	45	if (size == -ENODATA)
1da177e4	46	acl = NULL;
073aaa1b	47	else
1da177e4 LT	48	acl = ERR_PTR(size);
1da177e4 LT	49	} else {
5f3a4a28	50	acl = posix_acl_from_xattr(&init_user_ns, value, size);
1da177e4	51	}
259692bd	52	kfree(value);
1da177e4 LT	53	return acl;
	54	}
	55
2cc6a5a0	56	static int __jfs_set_acl(tid_t tid, struct inode *inode, int type,
4f4b401b	57	struct posix_acl *acl)
1da177e4 LT	58	{
1da177e4 LT	59	char *ea_name;
1da177e4 LT	60	int rc;
	61	int size = 0;
	62	char *value = NULL;
	63
2cc6a5a0 CH	64	switch (type) {
2cc6a5a0 CH	65	case ACL_TYPE_ACCESS:
97d79299	66	ea_name = XATTR_NAME_POSIX_ACL_ACCESS;
2cc6a5a0 CH	67	break;
2cc6a5a0 CH	68	case ACL_TYPE_DEFAULT:
97d79299	69	ea_name = XATTR_NAME_POSIX_ACL_DEFAULT;
2cc6a5a0 CH	70	break;
	71	default:
	72	return -EINVAL;
1da177e4	73	}
2cc6a5a0	74
1da177e4	75	if (acl) {
9a59f452	76	size = posix_acl_xattr_size(acl->a_count);
1da177e4 LT	77	value = kmalloc(size, GFP_KERNEL);
	78	if (!value)
	79	return -ENOMEM;
5f3a4a28	80	rc = posix_acl_to_xattr(&init_user_ns, acl, value, size);
1da177e4 LT	81	if (rc < 0)
	82	goto out;
	83	}
4f4b401b	84	rc = __jfs_setxattr(tid, inode, ea_name, value, size, 0);
1da177e4	85	out:
259692bd	86	kfree(value);
1da177e4	87
073aaa1b AV	88	if (!rc)
	89	set_cached_acl(inode, type, acl);
	90
1da177e4 LT	91	return rc;
	92	}
	93
2cc6a5a0 CH	94	int jfs_set_acl(struct inode inode, struct posix_acl acl, int type)
	95	{
	96	int rc;
	97	tid_t tid;
f070e5ac EF	98	int update_mode = 0;
f070e5ac EF	99	umode_t mode = inode->i_mode;
2cc6a5a0 CH	100
	101	tid = txBegin(inode->i_sb, 0);
	102	mutex_lock(&JFS_IP(inode)->commit_mutex);
9bcf66c7	103	if (type == ACL_TYPE_ACCESS && acl) {
f070e5ac	104	rc = posix_acl_update_mode(inode, &mode, &acl);
9bcf66c7 JK	105	if (rc)
9bcf66c7 JK	106	goto end_tx;
7ca5e8f0 CX	107	if (mode != inode->i_mode)
7ca5e8f0 CX	108	update_mode = 1;
9bcf66c7	109	}
2cc6a5a0	110	rc = __jfs_set_acl(tid, inode, type, acl);
f070e5ac EF	111	if (!rc) {
	112	if (update_mode) {
	113	inode->i_mode = mode;
	114	inode->i_ctime = current_time(inode);
	115	mark_inode_dirty(inode);
	116	}
2cc6a5a0	117	rc = txCommit(tid, 1, &inode, 0);
f070e5ac	118	}
9bcf66c7	119	end_tx:
2cc6a5a0 CH	120	txEnd(tid);
	121	mutex_unlock(&JFS_IP(inode)->commit_mutex);
	122	return rc;
	123	}
	124
4f4b401b	125	int jfs_init_acl(tid_t tid, struct inode inode, struct inode dir)
1da177e4	126	{
2cc6a5a0	127	struct posix_acl default_acl, acl;
1da177e4 LT	128	int rc = 0;
1da177e4 LT	129
2cc6a5a0 CH	130	rc = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl);
	131	if (rc)
	132	return rc;
1da177e4	133
2cc6a5a0 CH	134	if (default_acl) {
	135	rc = __jfs_set_acl(tid, inode, ACL_TYPE_DEFAULT, default_acl);
	136	posix_acl_release(default_acl);
e8d4ceeb CX	137	} else {
e8d4ceeb CX	138	inode->i_default_acl = NULL;
2cc6a5a0	139	}
1da177e4 LT	140
1da177e4 LT	141	if (acl) {
2cc6a5a0 CH	142	if (!rc)
2cc6a5a0 CH	143	rc = __jfs_set_acl(tid, inode, ACL_TYPE_ACCESS, acl);
1da177e4	144	posix_acl_release(acl);
e8d4ceeb CX	145	} else {
e8d4ceeb CX	146	inode->i_acl = NULL;
2cc6a5a0	147	}
63f83c9f	148
69eb66d7 DK	149	JFS_IP(inode)->mode2 = (JFS_IP(inode)->mode2 & 0xffff0000) \|
69eb66d7 DK	150	inode->i_mode;
1da177e4 LT	151
	152	return rc;
	153	}