![Chris Mason](/assets/img/avatar_default.png)
Linus noticed the btrfs code to cache acls wasn't properly caching a NULL acl when the inode didn't have any acls. This meant the common case of no acls resulted in expensive btree searches every time the kernel checked permissions (which is quite often). This is a modified version of Linus' original patch: Properly set initial acl fields to BTRFS_ACL_NOT_CACHED in the inode. This forces an acl lookup when permission checks are done. Fix btrfs_get_acl to avoid lookups and locking when the inode acls fields are set to null. Fix btrfs_get_acl to use the right return value from __btrfs_getxattr when deciding to cache a NULL acl. It was storing a NULL acl when __btrfs_getxattr return -ENOENT, but __btrfs_getxattr was actually returning -ENODATA for this case. Signed-off-by: Chris Mason <chris.mason@oracle.com>
360 lines
7.6 KiB
C
360 lines
7.6 KiB
C
/*
|
|
* Copyright (C) 2007 Red Hat. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public
|
|
* License v2 as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will 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 to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 021110-1307, USA.
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/string.h>
|
|
#include <linux/xattr.h>
|
|
#include <linux/posix_acl_xattr.h>
|
|
#include <linux/posix_acl.h>
|
|
#include <linux/sched.h>
|
|
|
|
#include "ctree.h"
|
|
#include "btrfs_inode.h"
|
|
#include "xattr.h"
|
|
|
|
#ifdef CONFIG_FS_POSIX_ACL
|
|
|
|
static void btrfs_update_cached_acl(struct inode *inode,
|
|
struct posix_acl **p_acl,
|
|
struct posix_acl *acl)
|
|
{
|
|
spin_lock(&inode->i_lock);
|
|
if (*p_acl && *p_acl != BTRFS_ACL_NOT_CACHED)
|
|
posix_acl_release(*p_acl);
|
|
*p_acl = posix_acl_dup(acl);
|
|
spin_unlock(&inode->i_lock);
|
|
}
|
|
|
|
static struct posix_acl *btrfs_get_acl(struct inode *inode, int type)
|
|
{
|
|
int size;
|
|
const char *name;
|
|
char *value = NULL;
|
|
struct posix_acl *acl = NULL, **p_acl;
|
|
|
|
switch (type) {
|
|
case ACL_TYPE_ACCESS:
|
|
name = POSIX_ACL_XATTR_ACCESS;
|
|
p_acl = &BTRFS_I(inode)->i_acl;
|
|
break;
|
|
case ACL_TYPE_DEFAULT:
|
|
name = POSIX_ACL_XATTR_DEFAULT;
|
|
p_acl = &BTRFS_I(inode)->i_default_acl;
|
|
break;
|
|
default:
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
/* Handle the cached NULL acl case without locking */
|
|
acl = ACCESS_ONCE(*p_acl);
|
|
if (!acl)
|
|
return acl;
|
|
|
|
spin_lock(&inode->i_lock);
|
|
acl = *p_acl;
|
|
if (acl != BTRFS_ACL_NOT_CACHED)
|
|
acl = posix_acl_dup(acl);
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
if (acl != BTRFS_ACL_NOT_CACHED)
|
|
return acl;
|
|
|
|
size = __btrfs_getxattr(inode, name, "", 0);
|
|
if (size > 0) {
|
|
value = kzalloc(size, GFP_NOFS);
|
|
if (!value)
|
|
return ERR_PTR(-ENOMEM);
|
|
size = __btrfs_getxattr(inode, name, value, size);
|
|
if (size > 0) {
|
|
acl = posix_acl_from_xattr(value, size);
|
|
btrfs_update_cached_acl(inode, p_acl, acl);
|
|
}
|
|
kfree(value);
|
|
} else if (size == -ENOENT || size == -ENODATA || size == 0) {
|
|
/* FIXME, who returns -ENOENT? I think nobody */
|
|
acl = NULL;
|
|
btrfs_update_cached_acl(inode, p_acl, acl);
|
|
} else {
|
|
acl = ERR_PTR(-EIO);
|
|
}
|
|
|
|
return acl;
|
|
}
|
|
|
|
static int btrfs_xattr_get_acl(struct inode *inode, int type,
|
|
void *value, size_t size)
|
|
{
|
|
struct posix_acl *acl;
|
|
int ret = 0;
|
|
|
|
acl = btrfs_get_acl(inode, type);
|
|
|
|
if (IS_ERR(acl))
|
|
return PTR_ERR(acl);
|
|
if (acl == NULL)
|
|
return -ENODATA;
|
|
ret = posix_acl_to_xattr(acl, value, size);
|
|
posix_acl_release(acl);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Needs to be called with fs_mutex held
|
|
*/
|
|
static int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
|
|
{
|
|
int ret, size = 0;
|
|
const char *name;
|
|
struct posix_acl **p_acl;
|
|
char *value = NULL;
|
|
mode_t mode;
|
|
|
|
if (acl) {
|
|
ret = posix_acl_valid(acl);
|
|
if (ret < 0)
|
|
return ret;
|
|
ret = 0;
|
|
}
|
|
|
|
switch (type) {
|
|
case ACL_TYPE_ACCESS:
|
|
mode = inode->i_mode;
|
|
ret = posix_acl_equiv_mode(acl, &mode);
|
|
if (ret < 0)
|
|
return ret;
|
|
ret = 0;
|
|
inode->i_mode = mode;
|
|
name = POSIX_ACL_XATTR_ACCESS;
|
|
p_acl = &BTRFS_I(inode)->i_acl;
|
|
break;
|
|
case ACL_TYPE_DEFAULT:
|
|
if (!S_ISDIR(inode->i_mode))
|
|
return acl ? -EINVAL : 0;
|
|
name = POSIX_ACL_XATTR_DEFAULT;
|
|
p_acl = &BTRFS_I(inode)->i_default_acl;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (acl) {
|
|
size = posix_acl_xattr_size(acl->a_count);
|
|
value = kmalloc(size, GFP_NOFS);
|
|
if (!value) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
ret = posix_acl_to_xattr(acl, value, size);
|
|
if (ret < 0)
|
|
goto out;
|
|
}
|
|
|
|
ret = __btrfs_setxattr(inode, name, value, size, 0);
|
|
|
|
out:
|
|
kfree(value);
|
|
|
|
if (!ret)
|
|
btrfs_update_cached_acl(inode, p_acl, acl);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int btrfs_xattr_set_acl(struct inode *inode, int type,
|
|
const void *value, size_t size)
|
|
{
|
|
int ret = 0;
|
|
struct posix_acl *acl = NULL;
|
|
|
|
if (value) {
|
|
acl = posix_acl_from_xattr(value, size);
|
|
if (acl == NULL) {
|
|
value = NULL;
|
|
size = 0;
|
|
} else if (IS_ERR(acl)) {
|
|
return PTR_ERR(acl);
|
|
}
|
|
}
|
|
|
|
ret = btrfs_set_acl(inode, acl, type);
|
|
|
|
posix_acl_release(acl);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int btrfs_xattr_acl_access_get(struct inode *inode, const char *name,
|
|
void *value, size_t size)
|
|
{
|
|
return btrfs_xattr_get_acl(inode, ACL_TYPE_ACCESS, value, size);
|
|
}
|
|
|
|
static int btrfs_xattr_acl_access_set(struct inode *inode, const char *name,
|
|
const void *value, size_t size, int flags)
|
|
{
|
|
return btrfs_xattr_set_acl(inode, ACL_TYPE_ACCESS, value, size);
|
|
}
|
|
|
|
static int btrfs_xattr_acl_default_get(struct inode *inode, const char *name,
|
|
void *value, size_t size)
|
|
{
|
|
return btrfs_xattr_get_acl(inode, ACL_TYPE_DEFAULT, value, size);
|
|
}
|
|
|
|
static int btrfs_xattr_acl_default_set(struct inode *inode, const char *name,
|
|
const void *value, size_t size, int flags)
|
|
{
|
|
return btrfs_xattr_set_acl(inode, ACL_TYPE_DEFAULT, value, size);
|
|
}
|
|
|
|
int btrfs_check_acl(struct inode *inode, int mask)
|
|
{
|
|
struct posix_acl *acl;
|
|
int error = -EAGAIN;
|
|
|
|
acl = btrfs_get_acl(inode, ACL_TYPE_ACCESS);
|
|
|
|
if (IS_ERR(acl))
|
|
return PTR_ERR(acl);
|
|
if (acl) {
|
|
error = posix_acl_permission(inode, acl, mask);
|
|
posix_acl_release(acl);
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
/*
|
|
* btrfs_init_acl is already generally called under fs_mutex, so the locking
|
|
* stuff has been fixed to work with that. If the locking stuff changes, we
|
|
* need to re-evaluate the acl locking stuff.
|
|
*/
|
|
int btrfs_init_acl(struct inode *inode, struct inode *dir)
|
|
{
|
|
struct posix_acl *acl = NULL;
|
|
int ret = 0;
|
|
|
|
/* this happens with subvols */
|
|
if (!dir)
|
|
return 0;
|
|
|
|
if (!S_ISLNK(inode->i_mode)) {
|
|
if (IS_POSIXACL(dir)) {
|
|
acl = btrfs_get_acl(dir, ACL_TYPE_DEFAULT);
|
|
if (IS_ERR(acl))
|
|
return PTR_ERR(acl);
|
|
}
|
|
|
|
if (!acl)
|
|
inode->i_mode &= ~current_umask();
|
|
}
|
|
|
|
if (IS_POSIXACL(dir) && acl) {
|
|
struct posix_acl *clone;
|
|
mode_t mode;
|
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
|
ret = btrfs_set_acl(inode, acl, ACL_TYPE_DEFAULT);
|
|
if (ret)
|
|
goto failed;
|
|
}
|
|
clone = posix_acl_clone(acl, GFP_NOFS);
|
|
ret = -ENOMEM;
|
|
if (!clone)
|
|
goto failed;
|
|
|
|
mode = inode->i_mode;
|
|
ret = posix_acl_create_masq(clone, &mode);
|
|
if (ret >= 0) {
|
|
inode->i_mode = mode;
|
|
if (ret > 0) {
|
|
/* we need an acl */
|
|
ret = btrfs_set_acl(inode, clone,
|
|
ACL_TYPE_ACCESS);
|
|
}
|
|
}
|
|
}
|
|
failed:
|
|
posix_acl_release(acl);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int btrfs_acl_chmod(struct inode *inode)
|
|
{
|
|
struct posix_acl *acl, *clone;
|
|
int ret = 0;
|
|
|
|
if (S_ISLNK(inode->i_mode))
|
|
return -EOPNOTSUPP;
|
|
|
|
if (!IS_POSIXACL(inode))
|
|
return 0;
|
|
|
|
acl = btrfs_get_acl(inode, ACL_TYPE_ACCESS);
|
|
if (IS_ERR(acl) || !acl)
|
|
return PTR_ERR(acl);
|
|
|
|
clone = posix_acl_clone(acl, GFP_KERNEL);
|
|
posix_acl_release(acl);
|
|
if (!clone)
|
|
return -ENOMEM;
|
|
|
|
ret = posix_acl_chmod_masq(clone, inode->i_mode);
|
|
if (!ret)
|
|
ret = btrfs_set_acl(inode, clone, ACL_TYPE_ACCESS);
|
|
|
|
posix_acl_release(clone);
|
|
|
|
return ret;
|
|
}
|
|
|
|
struct xattr_handler btrfs_xattr_acl_default_handler = {
|
|
.prefix = POSIX_ACL_XATTR_DEFAULT,
|
|
.get = btrfs_xattr_acl_default_get,
|
|
.set = btrfs_xattr_acl_default_set,
|
|
};
|
|
|
|
struct xattr_handler btrfs_xattr_acl_access_handler = {
|
|
.prefix = POSIX_ACL_XATTR_ACCESS,
|
|
.get = btrfs_xattr_acl_access_get,
|
|
.set = btrfs_xattr_acl_access_set,
|
|
};
|
|
|
|
#else /* CONFIG_FS_POSIX_ACL */
|
|
|
|
int btrfs_acl_chmod(struct inode *inode)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int btrfs_init_acl(struct inode *inode, struct inode *dir)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int btrfs_check_acl(struct inode *inode, int mask)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#endif /* CONFIG_FS_POSIX_ACL */
|