[linux.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, bool rcu)
{
	struct posix_acl *acl;
	char *ea_name;
	int size;
	char *value = NULL;

	if (rcu)
		return ERR_PTR(-ECHILD);

	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 mnt_idmap *idmap, struct dentry *dentry,
		struct posix_acl *acl, int type)
{
	int rc;
	tid_t tid;
	int update_mode = 0;
	struct inode *inode = d_inode(dentry);
	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(&nop_mnt_idmap, 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_set_ctime_current(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
0cad6246	17	struct posix_acl jfs_get_acl(struct inode inode, int type, bool rcu)
1da177e4 LT	18	{
	19	struct posix_acl *acl;
	20	char *ea_name;
1da177e4 LT	21	int size;
	22	char *value = NULL;
	23
0cad6246 MS	24	if (rcu)
	25	return ERR_PTR(-ECHILD);
	26
1da177e4 LT	27	switch(type) {
1da177e4 LT	28	case ACL_TYPE_ACCESS:
97d79299	29	ea_name = XATTR_NAME_POSIX_ACL_ACCESS;
1da177e4 LT	30	break;
1da177e4 LT	31	case ACL_TYPE_DEFAULT:
97d79299	32	ea_name = XATTR_NAME_POSIX_ACL_DEFAULT;
1da177e4 LT	33	break;
	34	default:
	35	return ERR_PTR(-EINVAL);
	36	}
	37
1da177e4 LT	38	size = __jfs_getxattr(inode, ea_name, NULL, 0);
	39
	40	if (size > 0) {
	41	value = kmalloc(size, GFP_KERNEL);
	42	if (!value)
	43	return ERR_PTR(-ENOMEM);
	44	size = __jfs_getxattr(inode, ea_name, value, size);
	45	}
	46
	47	if (size < 0) {
073aaa1b	48	if (size == -ENODATA)
1da177e4	49	acl = NULL;
073aaa1b	50	else
1da177e4 LT	51	acl = ERR_PTR(size);
1da177e4 LT	52	} else {
5f3a4a28	53	acl = posix_acl_from_xattr(&init_user_ns, value, size);
1da177e4	54	}
259692bd	55	kfree(value);
1da177e4 LT	56	return acl;
	57	}
	58
2cc6a5a0	59	static int __jfs_set_acl(tid_t tid, struct inode *inode, int type,
4f4b401b	60	struct posix_acl *acl)
1da177e4 LT	61	{
1da177e4 LT	62	char *ea_name;
1da177e4 LT	63	int rc;
	64	int size = 0;
	65	char *value = NULL;
	66
2cc6a5a0 CH	67	switch (type) {
2cc6a5a0 CH	68	case ACL_TYPE_ACCESS:
97d79299	69	ea_name = XATTR_NAME_POSIX_ACL_ACCESS;
2cc6a5a0 CH	70	break;
2cc6a5a0 CH	71	case ACL_TYPE_DEFAULT:
97d79299	72	ea_name = XATTR_NAME_POSIX_ACL_DEFAULT;
2cc6a5a0 CH	73	break;
	74	default:
	75	return -EINVAL;
1da177e4	76	}
2cc6a5a0	77
1da177e4	78	if (acl) {
9a59f452	79	size = posix_acl_xattr_size(acl->a_count);
1da177e4 LT	80	value = kmalloc(size, GFP_KERNEL);
	81	if (!value)
	82	return -ENOMEM;
5f3a4a28	83	rc = posix_acl_to_xattr(&init_user_ns, acl, value, size);
1da177e4 LT	84	if (rc < 0)
	85	goto out;
	86	}
4f4b401b	87	rc = __jfs_setxattr(tid, inode, ea_name, value, size, 0);
1da177e4	88	out:
259692bd	89	kfree(value);
1da177e4	90
073aaa1b AV	91	if (!rc)
	92	set_cached_acl(inode, type, acl);
	93
1da177e4 LT	94	return rc;
	95	}
	96
13e83a49	97	int jfs_set_acl(struct mnt_idmap idmap, struct dentry dentry,
549c7297	98	struct posix_acl *acl, int type)
2cc6a5a0 CH	99	{
	100	int rc;
	101	tid_t tid;
f070e5ac	102	int update_mode = 0;
138060ba	103	struct inode *inode = d_inode(dentry);
f070e5ac	104	umode_t mode = inode->i_mode;
2cc6a5a0 CH	105
	106	tid = txBegin(inode->i_sb, 0);
	107	mutex_lock(&JFS_IP(inode)->commit_mutex);
9bcf66c7	108	if (type == ACL_TYPE_ACCESS && acl) {
700b7940	109	rc = posix_acl_update_mode(&nop_mnt_idmap, inode, &mode, &acl);
9bcf66c7 JK	110	if (rc)
9bcf66c7 JK	111	goto end_tx;
7ca5e8f0 CX	112	if (mode != inode->i_mode)
7ca5e8f0 CX	113	update_mode = 1;
9bcf66c7	114	}
2cc6a5a0	115	rc = __jfs_set_acl(tid, inode, type, acl);
f070e5ac EF	116	if (!rc) {
	117	if (update_mode) {
	118	inode->i_mode = mode;
ad9dc5df	119	inode_set_ctime_current(inode);
f070e5ac EF	120	mark_inode_dirty(inode);
f070e5ac EF	121	}
2cc6a5a0	122	rc = txCommit(tid, 1, &inode, 0);
f070e5ac	123	}
9bcf66c7	124	end_tx:
2cc6a5a0 CH	125	txEnd(tid);
	126	mutex_unlock(&JFS_IP(inode)->commit_mutex);
	127	return rc;
	128	}
	129
4f4b401b	130	int jfs_init_acl(tid_t tid, struct inode inode, struct inode dir)
1da177e4	131	{
2cc6a5a0	132	struct posix_acl default_acl, acl;
1da177e4 LT	133	int rc = 0;
1da177e4 LT	134
2cc6a5a0 CH	135	rc = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl);
	136	if (rc)
	137	return rc;
1da177e4	138
2cc6a5a0 CH	139	if (default_acl) {
	140	rc = __jfs_set_acl(tid, inode, ACL_TYPE_DEFAULT, default_acl);
	141	posix_acl_release(default_acl);
e8d4ceeb CX	142	} else {
e8d4ceeb CX	143	inode->i_default_acl = NULL;
2cc6a5a0	144	}
1da177e4 LT	145
1da177e4 LT	146	if (acl) {
2cc6a5a0 CH	147	if (!rc)
2cc6a5a0 CH	148	rc = __jfs_set_acl(tid, inode, ACL_TYPE_ACCESS, acl);
1da177e4	149	posix_acl_release(acl);
e8d4ceeb CX	150	} else {
e8d4ceeb CX	151	inode->i_acl = NULL;
2cc6a5a0	152	}
63f83c9f	153
69eb66d7 DK	154	JFS_IP(inode)->mode2 = (JFS_IP(inode)->mode2 & 0xffff0000) \|
69eb66d7 DK	155	inode->i_mode;
1da177e4 LT	156
	157	return rc;
	158	}