mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 20:02:17 +00:00
![Mike Marshall](/assets/img/avatar_default.png)
Al Viro pointed out that I broke some acl functionality... * ACLs could not be fully removed * posix_acl_chmod would be called while the old ACL was still cached * new mode propagated to orangefs server before ACL. ... when I tried to make sure that modes that got changed as a result of ACL-sets would be sent back to the orangefs server. Not wanting to try and change the code without having some cases to test it with, I began to hunt for setfacl examples that were expressible in pure mode. Along the way I found examples like the following which confused me: user A had a file (/home/A/asdf) with mode 740 user B was in user A's group user C was not in user A's group setfacl -m u:C:rwx /home/A/asdf The above setfacl caused ls -l /home/A/asdf to show a mode of 770, making it appear that all users in user A's group now had full access to /home/A/asdf, however, user B still only had read acces. Madness. Anywho, I finally found that the above (whacky as it is) appears to be "posixly on purpose" and explained in acl(5): If the ACL has an ACL_MASK entry, the group permissions correspond to the permissions of the ACL_MASK entry. Signed-off-by: Mike Marshall <hubcap@omnibond.com>
193 lines
4.7 KiB
C
193 lines
4.7 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* (C) 2001 Clemson University and The University of Chicago
|
|
*
|
|
* See COPYING in top-level directory.
|
|
*/
|
|
|
|
#include "protocol.h"
|
|
#include "orangefs-kernel.h"
|
|
#include "orangefs-bufmap.h"
|
|
#include <linux/posix_acl_xattr.h>
|
|
|
|
struct posix_acl *orangefs_get_acl(struct inode *inode, int type)
|
|
{
|
|
struct posix_acl *acl;
|
|
int ret;
|
|
char *key = NULL, *value = NULL;
|
|
|
|
switch (type) {
|
|
case ACL_TYPE_ACCESS:
|
|
key = XATTR_NAME_POSIX_ACL_ACCESS;
|
|
break;
|
|
case ACL_TYPE_DEFAULT:
|
|
key = XATTR_NAME_POSIX_ACL_DEFAULT;
|
|
break;
|
|
default:
|
|
gossip_err("orangefs_get_acl: bogus value of type %d\n", type);
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
/*
|
|
* Rather than incurring a network call just to determine the exact
|
|
* length of the attribute, I just allocate a max length to save on
|
|
* the network call. Conceivably, we could pass NULL to
|
|
* orangefs_inode_getxattr() to probe the length of the value, but
|
|
* I don't do that for now.
|
|
*/
|
|
value = kmalloc(ORANGEFS_MAX_XATTR_VALUELEN, GFP_KERNEL);
|
|
if (!value)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
gossip_debug(GOSSIP_ACL_DEBUG,
|
|
"inode %pU, key %s, type %d\n",
|
|
get_khandle_from_ino(inode),
|
|
key,
|
|
type);
|
|
ret = orangefs_inode_getxattr(inode, key, value,
|
|
ORANGEFS_MAX_XATTR_VALUELEN);
|
|
/* if the key exists, convert it to an in-memory rep */
|
|
if (ret > 0) {
|
|
acl = posix_acl_from_xattr(&init_user_ns, value, ret);
|
|
} else if (ret == -ENODATA || ret == -ENOSYS) {
|
|
acl = NULL;
|
|
} else {
|
|
gossip_err("inode %pU retrieving acl's failed with error %d\n",
|
|
get_khandle_from_ino(inode),
|
|
ret);
|
|
acl = ERR_PTR(ret);
|
|
}
|
|
/* kfree(NULL) is safe, so don't worry if value ever got used */
|
|
kfree(value);
|
|
return acl;
|
|
}
|
|
|
|
static int __orangefs_set_acl(struct inode *inode, struct posix_acl *acl,
|
|
int type)
|
|
{
|
|
int error = 0;
|
|
void *value = NULL;
|
|
size_t size = 0;
|
|
const char *name = NULL;
|
|
|
|
switch (type) {
|
|
case ACL_TYPE_ACCESS:
|
|
name = XATTR_NAME_POSIX_ACL_ACCESS;
|
|
break;
|
|
case ACL_TYPE_DEFAULT:
|
|
name = XATTR_NAME_POSIX_ACL_DEFAULT;
|
|
break;
|
|
default:
|
|
gossip_err("%s: invalid type %d!\n", __func__, type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
gossip_debug(GOSSIP_ACL_DEBUG,
|
|
"%s: inode %pU, key %s type %d\n",
|
|
__func__, get_khandle_from_ino(inode),
|
|
name,
|
|
type);
|
|
|
|
if (acl) {
|
|
size = posix_acl_xattr_size(acl->a_count);
|
|
value = kmalloc(size, GFP_KERNEL);
|
|
if (!value)
|
|
return -ENOMEM;
|
|
|
|
error = posix_acl_to_xattr(&init_user_ns, acl, value, size);
|
|
if (error < 0)
|
|
goto out;
|
|
}
|
|
|
|
gossip_debug(GOSSIP_ACL_DEBUG,
|
|
"%s: name %s, value %p, size %zd, acl %p\n",
|
|
__func__, name, value, size, acl);
|
|
/*
|
|
* Go ahead and set the extended attribute now. NOTE: Suppose acl
|
|
* was NULL, then value will be NULL and size will be 0 and that
|
|
* will xlate to a removexattr. However, we don't want removexattr
|
|
* complain if attributes does not exist.
|
|
*/
|
|
error = orangefs_inode_setxattr(inode, name, value, size, 0);
|
|
|
|
out:
|
|
kfree(value);
|
|
if (!error)
|
|
set_cached_acl(inode, type, acl);
|
|
return error;
|
|
}
|
|
|
|
int orangefs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
|
|
{
|
|
int error;
|
|
struct iattr iattr;
|
|
int rc;
|
|
|
|
memset(&iattr, 0, sizeof iattr);
|
|
|
|
if (type == ACL_TYPE_ACCESS && acl) {
|
|
/*
|
|
* posix_acl_update_mode checks to see if the permissions
|
|
* described by the ACL can be encoded into the
|
|
* object's mode. If so, it sets "acl" to NULL
|
|
* and "mode" to the new desired value. It is up to
|
|
* us to propagate the new mode back to the server...
|
|
*/
|
|
error = posix_acl_update_mode(inode, &iattr.ia_mode, &acl);
|
|
if (error) {
|
|
gossip_err("%s: posix_acl_update_mode err: %d\n",
|
|
__func__,
|
|
error);
|
|
return error;
|
|
}
|
|
|
|
if (inode->i_mode != iattr.ia_mode)
|
|
iattr.ia_valid = ATTR_MODE;
|
|
|
|
}
|
|
|
|
rc = __orangefs_set_acl(inode, acl, type);
|
|
|
|
if (!rc && (iattr.ia_valid == ATTR_MODE))
|
|
rc = __orangefs_setattr(inode, &iattr);
|
|
|
|
return rc;
|
|
}
|
|
|
|
int orangefs_init_acl(struct inode *inode, struct inode *dir)
|
|
{
|
|
struct posix_acl *default_acl, *acl;
|
|
umode_t mode = inode->i_mode;
|
|
struct iattr iattr;
|
|
int error = 0;
|
|
|
|
error = posix_acl_create(dir, &mode, &default_acl, &acl);
|
|
if (error)
|
|
return error;
|
|
|
|
if (default_acl) {
|
|
error = __orangefs_set_acl(inode, default_acl,
|
|
ACL_TYPE_DEFAULT);
|
|
posix_acl_release(default_acl);
|
|
} else {
|
|
inode->i_default_acl = NULL;
|
|
}
|
|
|
|
if (acl) {
|
|
if (!error)
|
|
error = __orangefs_set_acl(inode, acl, ACL_TYPE_ACCESS);
|
|
posix_acl_release(acl);
|
|
} else {
|
|
inode->i_acl = NULL;
|
|
}
|
|
|
|
/* If mode of the inode was changed, then do a forcible ->setattr */
|
|
if (mode != inode->i_mode) {
|
|
memset(&iattr, 0, sizeof iattr);
|
|
inode->i_mode = mode;
|
|
iattr.ia_mode = mode;
|
|
iattr.ia_valid |= ATTR_MODE;
|
|
__orangefs_setattr(inode, &iattr);
|
|
}
|
|
|
|
return error;
|
|
}
|