2011-01-26 20:10:01 +00:00
|
|
|
/*
|
|
|
|
* CDDL HEADER START
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the terms of the
|
|
|
|
* Common Development and Distribution License (the "License").
|
|
|
|
* You may not use this file except in compliance with the License.
|
|
|
|
*
|
|
|
|
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
|
|
|
|
* or http://www.opensolaris.org/os/licensing.
|
|
|
|
* See the License for the specific language governing permissions
|
|
|
|
* and limitations under the License.
|
|
|
|
*
|
|
|
|
* When distributing Covered Code, include this CDDL HEADER in each
|
|
|
|
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
|
|
|
* If applicable, add the following below this CDDL HEADER, with the
|
|
|
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
|
|
|
* information: Portions Copyright [yyyy] [name of copyright owner]
|
|
|
|
*
|
|
|
|
* CDDL HEADER END
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* Copyright (c) 2011, Lawrence Livermore National Security, LLC.
|
|
|
|
*
|
|
|
|
* Extended attributes (xattr) on Solaris are implemented as files
|
|
|
|
* which exist in a hidden xattr directory. These extended attributes
|
|
|
|
* can be accessed using the attropen() system call which opens
|
|
|
|
* the extended attribute. It can then be manipulated just like
|
|
|
|
* a standard file descriptor. This has a couple advantages such
|
|
|
|
* as practically no size limit on the file, and the extended
|
|
|
|
* attributes permissions may differ from those of the parent file.
|
|
|
|
* This interface is really quite clever, but it's also completely
|
2011-10-24 23:55:20 +00:00
|
|
|
* different than what is supported on Linux. It also comes with a
|
|
|
|
* steep performance penalty when accessing small xattrs because they
|
|
|
|
* are not stored with the parent file.
|
2011-01-26 20:10:01 +00:00
|
|
|
*
|
|
|
|
* Under Linux extended attributes are manipulated by the system
|
|
|
|
* calls getxattr(2), setxattr(2), and listxattr(2). They consider
|
|
|
|
* extended attributes to be name/value pairs where the name is a
|
|
|
|
* NULL terminated string. The name must also include one of the
|
2011-10-24 23:55:20 +00:00
|
|
|
* following namespace prefixes:
|
2011-01-26 20:10:01 +00:00
|
|
|
*
|
|
|
|
* user - No restrictions and is available to user applications.
|
|
|
|
* trusted - Restricted to kernel and root (CAP_SYS_ADMIN) use.
|
|
|
|
* system - Used for access control lists (system.nfs4_acl, etc).
|
|
|
|
* security - Used by SELinux to store a files security context.
|
|
|
|
*
|
2011-10-24 23:55:20 +00:00
|
|
|
* The value under Linux to limited to 65536 bytes of binary data.
|
|
|
|
* In practice, individual xattrs tend to be much smaller than this
|
|
|
|
* and are typically less than 100 bytes. A good example of this
|
|
|
|
* are the security.selinux xattrs which are less than 100 bytes and
|
|
|
|
* exist for every file when xattr labeling is enabled.
|
2011-01-26 20:10:01 +00:00
|
|
|
*
|
2011-10-24 23:55:20 +00:00
|
|
|
* The Linux xattr implemenation has been written to take advantage of
|
|
|
|
* this typical usage. When the dataset property 'xattr=sa' is set,
|
|
|
|
* then xattrs will be preferentially stored as System Attributes (SA).
|
|
|
|
* This allows tiny xattrs (~100 bytes) to be stored with the dnode and
|
|
|
|
* up to 64k of xattrs to be stored in the spill block. If additional
|
|
|
|
* xattr space is required, which is unlikely under Linux, they will
|
|
|
|
* be stored using the traditional directory approach.
|
2011-01-26 20:10:01 +00:00
|
|
|
*
|
2011-10-24 23:55:20 +00:00
|
|
|
* This optimization results in roughly a 3x performance improvement
|
|
|
|
* when accessing xattrs because it avoids the need to perform a seek
|
|
|
|
* for every xattr value. When multiple xattrs are stored per-file
|
|
|
|
* the performance improvements are even greater because all of the
|
|
|
|
* xattrs stored in the spill block will be cached.
|
|
|
|
*
|
|
|
|
* However, by default SA based xattrs are disabled in the Linux port
|
|
|
|
* to maximize compatibility with other implementations. If you do
|
|
|
|
* enable SA based xattrs then they will not be visible on platforms
|
|
|
|
* which do not support this feature.
|
|
|
|
*
|
|
|
|
* NOTE: One additional consequence of the xattr directory implementation
|
|
|
|
* is that when an extended attribute is manipulated an inode is created.
|
|
|
|
* This inode will exist in the Linux inode cache but there will be no
|
|
|
|
* associated entry in the dentry cache which references it. This is
|
|
|
|
* safe but it may result in some confusion. Enabling SA based xattrs
|
|
|
|
* largely avoids the issue except in the overflow case.
|
2011-01-26 20:10:01 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/zfs_vfsops.h>
|
|
|
|
#include <sys/zfs_vnops.h>
|
|
|
|
#include <sys/zfs_znode.h>
|
2013-08-07 12:53:45 +00:00
|
|
|
#include <sys/zap.h>
|
2011-01-26 20:10:01 +00:00
|
|
|
#include <sys/vfs.h>
|
|
|
|
#include <sys/zpl.h>
|
|
|
|
|
|
|
|
typedef struct xattr_filldir {
|
|
|
|
size_t size;
|
|
|
|
size_t offset;
|
|
|
|
char *buf;
|
|
|
|
struct inode *inode;
|
|
|
|
} xattr_filldir_t;
|
|
|
|
|
|
|
|
static int
|
2013-08-07 12:53:45 +00:00
|
|
|
zpl_xattr_filldir(xattr_filldir_t *xf, const char *name, int name_len)
|
2011-01-26 20:10:01 +00:00
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
if (strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) == 0)
|
2011-05-19 18:44:07 +00:00
|
|
|
if (!(ITOZSB(xf->inode)->z_flags & ZSB_XATTR))
|
2011-01-26 20:10:01 +00:00
|
|
|
return (0);
|
|
|
|
|
2013-11-01 19:26:11 +00:00
|
|
|
if (strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0)
|
2011-01-26 20:10:01 +00:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
/* When xf->buf is NULL only calculate the required size. */
|
|
|
|
if (xf->buf) {
|
|
|
|
if (xf->offset + name_len + 1 > xf->size)
|
|
|
|
return (-ERANGE);
|
|
|
|
|
|
|
|
memcpy(xf->buf + xf->offset, name, name_len);
|
|
|
|
xf->buf[xf->offset + name_len] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
xf->offset += (name_len + 1);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2013-08-07 12:53:45 +00:00
|
|
|
/*
|
|
|
|
* Read as many directory entry names as will fit in to the provided buffer,
|
|
|
|
* or when no buffer is provided calculate the required buffer size.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
zpl_xattr_readdir(struct inode *dxip, xattr_filldir_t *xf)
|
|
|
|
{
|
|
|
|
zap_cursor_t zc;
|
|
|
|
zap_attribute_t zap;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
zap_cursor_init(&zc, ITOZSB(dxip)->z_os, ITOZ(dxip)->z_id);
|
|
|
|
|
|
|
|
while ((error = -zap_cursor_retrieve(&zc, &zap)) == 0) {
|
|
|
|
|
|
|
|
if (zap.za_integer_length != 8 || zap.za_num_integers != 1) {
|
|
|
|
error = -ENXIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = zpl_xattr_filldir(xf, zap.za_name, strlen(zap.za_name));
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
|
|
|
|
zap_cursor_advance(&zc);
|
|
|
|
}
|
|
|
|
|
|
|
|
zap_cursor_fini(&zc);
|
|
|
|
|
|
|
|
if (error == -ENOENT)
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-10-24 23:55:20 +00:00
|
|
|
static ssize_t
|
|
|
|
zpl_xattr_list_dir(xattr_filldir_t *xf, cred_t *cr)
|
2011-01-26 20:10:01 +00:00
|
|
|
{
|
2011-10-24 23:55:20 +00:00
|
|
|
struct inode *ip = xf->inode;
|
2011-01-26 20:10:01 +00:00
|
|
|
struct inode *dxip = NULL;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* Lookup the xattr directory */
|
|
|
|
error = -zfs_lookup(ip, NULL, &dxip, LOOKUP_XATTR, cr, NULL, NULL);
|
|
|
|
if (error) {
|
|
|
|
if (error == -ENOENT)
|
|
|
|
error = 0;
|
|
|
|
|
2011-10-24 23:55:20 +00:00
|
|
|
return (error);
|
2011-01-26 20:10:01 +00:00
|
|
|
}
|
|
|
|
|
2013-08-07 12:53:45 +00:00
|
|
|
error = zpl_xattr_readdir(dxip, xf);
|
2011-10-24 23:55:20 +00:00
|
|
|
iput(dxip);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
zpl_xattr_list_sa(xattr_filldir_t *xf)
|
|
|
|
{
|
|
|
|
znode_t *zp = ITOZ(xf->inode);
|
|
|
|
nvpair_t *nvp = NULL;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
mutex_enter(&zp->z_lock);
|
|
|
|
if (zp->z_xattr_cached == NULL)
|
|
|
|
error = -zfs_sa_get_xattr(zp);
|
|
|
|
mutex_exit(&zp->z_lock);
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
ASSERT(zp->z_xattr_cached);
|
|
|
|
|
|
|
|
while ((nvp = nvlist_next_nvpair(zp->z_xattr_cached, nvp)) != NULL) {
|
|
|
|
ASSERT3U(nvpair_type(nvp), ==, DATA_TYPE_BYTE_ARRAY);
|
|
|
|
|
2013-08-07 12:53:45 +00:00
|
|
|
error = zpl_xattr_filldir(xf, nvpair_name(nvp),
|
2013-11-01 19:26:11 +00:00
|
|
|
strlen(nvpair_name(nvp)));
|
2011-10-24 23:55:20 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
ssize_t
|
|
|
|
zpl_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
|
|
|
|
{
|
|
|
|
znode_t *zp = ITOZ(dentry->d_inode);
|
|
|
|
zfs_sb_t *zsb = ZTOZSB(zp);
|
|
|
|
xattr_filldir_t xf = { buffer_size, 0, buffer, dentry->d_inode };
|
|
|
|
cred_t *cr = CRED();
|
2015-04-14 17:25:50 +00:00
|
|
|
fstrans_cookie_t cookie;
|
2011-10-24 23:55:20 +00:00
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
crhold(cr);
|
2015-04-14 17:25:50 +00:00
|
|
|
cookie = spl_fstrans_mark();
|
2011-10-24 23:55:20 +00:00
|
|
|
rw_enter(&zp->z_xattr_lock, RW_READER);
|
|
|
|
|
|
|
|
if (zsb->z_use_sa && zp->z_is_sa) {
|
|
|
|
error = zpl_xattr_list_sa(&xf);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = zpl_xattr_list_dir(&xf, cr);
|
2011-01-26 20:10:01 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
error = xf.offset;
|
|
|
|
out:
|
|
|
|
|
2011-10-24 23:55:20 +00:00
|
|
|
rw_exit(&zp->z_xattr_lock);
|
2015-04-14 17:25:50 +00:00
|
|
|
spl_fstrans_unmark(cookie);
|
2011-03-22 18:13:41 +00:00
|
|
|
crfree(cr);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2011-10-24 23:55:20 +00:00
|
|
|
zpl_xattr_get_dir(struct inode *ip, const char *name, void *value,
|
|
|
|
size_t size, cred_t *cr)
|
2011-01-26 20:10:01 +00:00
|
|
|
{
|
|
|
|
struct inode *dxip = NULL;
|
|
|
|
struct inode *xip = NULL;
|
Linux AIO Support
nfsd uses do_readv_writev() to implement fops->read and fops->write.
do_readv_writev() will attempt to read/write using fops->aio_read and
fops->aio_write, but it will fallback to fops->read and fops->write when
AIO is not available. However, the fallback will perform a call for each
individual data page. Since our default recordsize is 128KB, sequential
operations on NFS will generate 32 DMU transactions where only 1
transaction was needed. That was unnecessary overhead and we implement
fops->aio_read and fops->aio_write to eliminate it.
ZFS originated in OpenSolaris, where the AIO API is entirely implemented
in userland's libc by intelligently mapping them to VOP_WRITE, VOP_READ
and VOP_FSYNC. Linux implements AIO inside the kernel itself. Linux
filesystems therefore must implement their own AIO logic and nearly all
of them implement fops->aio_write synchronously. Consequently, they do
not implement aio_fsync(). However, since the ZPL works by mapping
Linux's VFS calls to the functions implementing Illumos' VFS operations,
we instead implement AIO in the kernel by mapping the operations to the
VOP_READ, VOP_WRITE and VOP_FSYNC equivalents. We therefore implement
fops->aio_fsync.
One might be inclined to make our fops->aio_write implementation
synchronous to make software that expects this behavior safe. However,
there are several reasons not to do this:
1. Other platforms do not implement aio_write() synchronously and since
the majority of userland software using AIO should be cross platform,
expectations of synchronous behavior should not be a problem.
2. We would hurt the performance of programs that use POSIX interfaces
properly while simultaneously encouraging the creation of more
non-compliant software.
3. The broader community concluded that userland software should be
patched to properly use POSIX interfaces instead of implementing hacks
in filesystems to cater to broken software. This concept is best
described as the O_PONIES debate.
4. Making an asynchronous write synchronous is non sequitur.
Any software dependent on synchronous aio_write behavior will suffer
data loss on ZFSOnLinux in a kernel panic / system failure of at most
zfs_txg_timeout seconds, which by default is 5 seconds. This seems like
a reasonable consequence of using non-compliant software.
It should be noted that this is also a problem in the kernel itself
where nfsd does not pass O_SYNC on files opened with it and instead
relies on a open()/write()/close() to enforce synchronous behavior when
the flush is only guarenteed on last close.
Exporting any filesystem that does not implement AIO via NFS risks data
loss in the event of a kernel panic / system failure when something else
is also accessing the file. Exporting any file system that implements
AIO the way this patch does bears similar risk. However, it seems
reasonable to forgo crippling our AIO implementation in favor of
developing patches to fix this problem in Linux's nfsd for the reasons
stated earlier. In the interim, the risk will remain. Failing to
implement AIO will not change the problem that nfsd created, so there is
no reason for nfsd's mistake to block our implementation of AIO.
It also should be noted that `aio_cancel()` will always return
`AIO_NOTCANCELED` under this implementation. It is possible to implement
aio_cancel by deferring work to taskqs and use `kiocb_set_cancel_fn()`
to set a callback function for cancelling work sent to taskqs, but the
simpler approach is allowed by the specification:
```
Which operations are cancelable is implementation-defined.
```
http://pubs.opengroup.org/onlinepubs/009695399/functions/aio_cancel.html
The only programs on my system that are capable of using `aio_cancel()`
are QEMU, beecrypt and fio use it according to a recursive grep of my
system's `/usr/src/debug`. That suggests that `aio_cancel()` users are
rare. Implementing aio_cancel() is left to a future date when it is
clear that there are consumers that benefit from its implementation to
justify the work.
Lastly, it is important to know that handling of the iovec updates differs
between Illumos and Linux in the implementation of read/write. On Linux,
it is the VFS' responsibility whle on Illumos, it is the filesystem's
responsibility. We take the intermediate solution of copying the iovec
so that the ZFS code can update it like on Solaris while leaving the
originals alone. This imposes some overhead. We could always revisit
this should profiling show that the allocations are a problem.
Signed-off-by: Richard Yao <ryao@gentoo.org>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Closes #223
Closes #2373
2014-08-04 11:09:32 +00:00
|
|
|
loff_t pos = 0;
|
2011-01-26 20:10:01 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
/* Lookup the xattr directory */
|
|
|
|
error = -zfs_lookup(ip, NULL, &dxip, LOOKUP_XATTR, cr, NULL, NULL);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Lookup a specific xattr name in the directory */
|
|
|
|
error = -zfs_lookup(dxip, (char *)name, &xip, 0, cr, NULL, NULL);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (!size) {
|
|
|
|
error = i_size_read(xip);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-04-17 20:07:36 +00:00
|
|
|
if (size < i_size_read(xip)) {
|
|
|
|
error = -ERANGE;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
Linux AIO Support
nfsd uses do_readv_writev() to implement fops->read and fops->write.
do_readv_writev() will attempt to read/write using fops->aio_read and
fops->aio_write, but it will fallback to fops->read and fops->write when
AIO is not available. However, the fallback will perform a call for each
individual data page. Since our default recordsize is 128KB, sequential
operations on NFS will generate 32 DMU transactions where only 1
transaction was needed. That was unnecessary overhead and we implement
fops->aio_read and fops->aio_write to eliminate it.
ZFS originated in OpenSolaris, where the AIO API is entirely implemented
in userland's libc by intelligently mapping them to VOP_WRITE, VOP_READ
and VOP_FSYNC. Linux implements AIO inside the kernel itself. Linux
filesystems therefore must implement their own AIO logic and nearly all
of them implement fops->aio_write synchronously. Consequently, they do
not implement aio_fsync(). However, since the ZPL works by mapping
Linux's VFS calls to the functions implementing Illumos' VFS operations,
we instead implement AIO in the kernel by mapping the operations to the
VOP_READ, VOP_WRITE and VOP_FSYNC equivalents. We therefore implement
fops->aio_fsync.
One might be inclined to make our fops->aio_write implementation
synchronous to make software that expects this behavior safe. However,
there are several reasons not to do this:
1. Other platforms do not implement aio_write() synchronously and since
the majority of userland software using AIO should be cross platform,
expectations of synchronous behavior should not be a problem.
2. We would hurt the performance of programs that use POSIX interfaces
properly while simultaneously encouraging the creation of more
non-compliant software.
3. The broader community concluded that userland software should be
patched to properly use POSIX interfaces instead of implementing hacks
in filesystems to cater to broken software. This concept is best
described as the O_PONIES debate.
4. Making an asynchronous write synchronous is non sequitur.
Any software dependent on synchronous aio_write behavior will suffer
data loss on ZFSOnLinux in a kernel panic / system failure of at most
zfs_txg_timeout seconds, which by default is 5 seconds. This seems like
a reasonable consequence of using non-compliant software.
It should be noted that this is also a problem in the kernel itself
where nfsd does not pass O_SYNC on files opened with it and instead
relies on a open()/write()/close() to enforce synchronous behavior when
the flush is only guarenteed on last close.
Exporting any filesystem that does not implement AIO via NFS risks data
loss in the event of a kernel panic / system failure when something else
is also accessing the file. Exporting any file system that implements
AIO the way this patch does bears similar risk. However, it seems
reasonable to forgo crippling our AIO implementation in favor of
developing patches to fix this problem in Linux's nfsd for the reasons
stated earlier. In the interim, the risk will remain. Failing to
implement AIO will not change the problem that nfsd created, so there is
no reason for nfsd's mistake to block our implementation of AIO.
It also should be noted that `aio_cancel()` will always return
`AIO_NOTCANCELED` under this implementation. It is possible to implement
aio_cancel by deferring work to taskqs and use `kiocb_set_cancel_fn()`
to set a callback function for cancelling work sent to taskqs, but the
simpler approach is allowed by the specification:
```
Which operations are cancelable is implementation-defined.
```
http://pubs.opengroup.org/onlinepubs/009695399/functions/aio_cancel.html
The only programs on my system that are capable of using `aio_cancel()`
are QEMU, beecrypt and fio use it according to a recursive grep of my
system's `/usr/src/debug`. That suggests that `aio_cancel()` users are
rare. Implementing aio_cancel() is left to a future date when it is
clear that there are consumers that benefit from its implementation to
justify the work.
Lastly, it is important to know that handling of the iovec updates differs
between Illumos and Linux in the implementation of read/write. On Linux,
it is the VFS' responsibility whle on Illumos, it is the filesystem's
responsibility. We take the intermediate solution of copying the iovec
so that the ZFS code can update it like on Solaris while leaving the
originals alone. This imposes some overhead. We could always revisit
this should profiling show that the allocations are a problem.
Signed-off-by: Richard Yao <ryao@gentoo.org>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Closes #223
Closes #2373
2014-08-04 11:09:32 +00:00
|
|
|
error = zpl_read_common(xip, value, size, &pos, UIO_SYSSPACE, 0, cr);
|
2011-01-26 20:10:01 +00:00
|
|
|
out:
|
|
|
|
if (xip)
|
|
|
|
iput(xip);
|
|
|
|
|
|
|
|
if (dxip)
|
|
|
|
iput(dxip);
|
|
|
|
|
2011-10-24 23:55:20 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_get_sa(struct inode *ip, const char *name, void *value, size_t size)
|
|
|
|
{
|
|
|
|
znode_t *zp = ITOZ(ip);
|
|
|
|
uchar_t *nv_value;
|
|
|
|
uint_t nv_size;
|
|
|
|
int error = 0;
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2011-10-24 23:55:20 +00:00
|
|
|
ASSERT(RW_LOCK_HELD(&zp->z_xattr_lock));
|
|
|
|
|
|
|
|
mutex_enter(&zp->z_lock);
|
|
|
|
if (zp->z_xattr_cached == NULL)
|
|
|
|
error = -zfs_sa_get_xattr(zp);
|
|
|
|
mutex_exit(&zp->z_lock);
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
ASSERT(zp->z_xattr_cached);
|
|
|
|
error = -nvlist_lookup_byte_array(zp->z_xattr_cached, name,
|
|
|
|
&nv_value, &nv_size);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
if (!size)
|
|
|
|
return (nv_size);
|
|
|
|
|
2013-04-17 20:07:36 +00:00
|
|
|
if (size < nv_size)
|
|
|
|
return (-ERANGE);
|
|
|
|
|
|
|
|
memcpy(value, nv_value, nv_size);
|
2011-10-24 23:55:20 +00:00
|
|
|
|
2013-04-17 20:07:36 +00:00
|
|
|
return (nv_size);
|
2011-10-24 23:55:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
__zpl_xattr_get(struct inode *ip, const char *name, void *value, size_t size,
|
|
|
|
cred_t *cr)
|
|
|
|
{
|
|
|
|
znode_t *zp = ITOZ(ip);
|
|
|
|
zfs_sb_t *zsb = ZTOZSB(zp);
|
|
|
|
int error;
|
|
|
|
|
|
|
|
ASSERT(RW_LOCK_HELD(&zp->z_xattr_lock));
|
|
|
|
|
|
|
|
if (zsb->z_use_sa && zp->z_is_sa) {
|
|
|
|
error = zpl_xattr_get_sa(ip, name, value, size);
|
2013-05-08 16:20:04 +00:00
|
|
|
if (error != -ENOENT)
|
2011-10-24 23:55:20 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = zpl_xattr_get_dir(ip, name, value, size, cr);
|
|
|
|
out:
|
2011-01-26 20:10:01 +00:00
|
|
|
if (error == -ENOENT)
|
|
|
|
error = -ENODATA;
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2011-10-24 23:55:20 +00:00
|
|
|
zpl_xattr_get(struct inode *ip, const char *name, void *value, size_t size)
|
|
|
|
{
|
|
|
|
znode_t *zp = ITOZ(ip);
|
|
|
|
cred_t *cr = CRED();
|
2015-04-14 17:25:50 +00:00
|
|
|
fstrans_cookie_t cookie;
|
2011-10-24 23:55:20 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
crhold(cr);
|
2015-04-14 17:25:50 +00:00
|
|
|
cookie = spl_fstrans_mark();
|
2011-10-24 23:55:20 +00:00
|
|
|
rw_enter(&zp->z_xattr_lock, RW_READER);
|
|
|
|
error = __zpl_xattr_get(ip, name, value, size, cr);
|
|
|
|
rw_exit(&zp->z_xattr_lock);
|
2015-04-14 17:25:50 +00:00
|
|
|
spl_fstrans_unmark(cookie);
|
2011-10-24 23:55:20 +00:00
|
|
|
crfree(cr);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_set_dir(struct inode *ip, const char *name, const void *value,
|
|
|
|
size_t size, int flags, cred_t *cr)
|
2011-01-26 20:10:01 +00:00
|
|
|
{
|
|
|
|
struct inode *dxip = NULL;
|
|
|
|
struct inode *xip = NULL;
|
|
|
|
vattr_t *vap = NULL;
|
|
|
|
ssize_t wrote;
|
2013-10-28 16:07:00 +00:00
|
|
|
int lookup_flags, error;
|
2011-04-17 18:31:33 +00:00
|
|
|
const int xattr_mode = S_IFREG | 0644;
|
Linux AIO Support
nfsd uses do_readv_writev() to implement fops->read and fops->write.
do_readv_writev() will attempt to read/write using fops->aio_read and
fops->aio_write, but it will fallback to fops->read and fops->write when
AIO is not available. However, the fallback will perform a call for each
individual data page. Since our default recordsize is 128KB, sequential
operations on NFS will generate 32 DMU transactions where only 1
transaction was needed. That was unnecessary overhead and we implement
fops->aio_read and fops->aio_write to eliminate it.
ZFS originated in OpenSolaris, where the AIO API is entirely implemented
in userland's libc by intelligently mapping them to VOP_WRITE, VOP_READ
and VOP_FSYNC. Linux implements AIO inside the kernel itself. Linux
filesystems therefore must implement their own AIO logic and nearly all
of them implement fops->aio_write synchronously. Consequently, they do
not implement aio_fsync(). However, since the ZPL works by mapping
Linux's VFS calls to the functions implementing Illumos' VFS operations,
we instead implement AIO in the kernel by mapping the operations to the
VOP_READ, VOP_WRITE and VOP_FSYNC equivalents. We therefore implement
fops->aio_fsync.
One might be inclined to make our fops->aio_write implementation
synchronous to make software that expects this behavior safe. However,
there are several reasons not to do this:
1. Other platforms do not implement aio_write() synchronously and since
the majority of userland software using AIO should be cross platform,
expectations of synchronous behavior should not be a problem.
2. We would hurt the performance of programs that use POSIX interfaces
properly while simultaneously encouraging the creation of more
non-compliant software.
3. The broader community concluded that userland software should be
patched to properly use POSIX interfaces instead of implementing hacks
in filesystems to cater to broken software. This concept is best
described as the O_PONIES debate.
4. Making an asynchronous write synchronous is non sequitur.
Any software dependent on synchronous aio_write behavior will suffer
data loss on ZFSOnLinux in a kernel panic / system failure of at most
zfs_txg_timeout seconds, which by default is 5 seconds. This seems like
a reasonable consequence of using non-compliant software.
It should be noted that this is also a problem in the kernel itself
where nfsd does not pass O_SYNC on files opened with it and instead
relies on a open()/write()/close() to enforce synchronous behavior when
the flush is only guarenteed on last close.
Exporting any filesystem that does not implement AIO via NFS risks data
loss in the event of a kernel panic / system failure when something else
is also accessing the file. Exporting any file system that implements
AIO the way this patch does bears similar risk. However, it seems
reasonable to forgo crippling our AIO implementation in favor of
developing patches to fix this problem in Linux's nfsd for the reasons
stated earlier. In the interim, the risk will remain. Failing to
implement AIO will not change the problem that nfsd created, so there is
no reason for nfsd's mistake to block our implementation of AIO.
It also should be noted that `aio_cancel()` will always return
`AIO_NOTCANCELED` under this implementation. It is possible to implement
aio_cancel by deferring work to taskqs and use `kiocb_set_cancel_fn()`
to set a callback function for cancelling work sent to taskqs, but the
simpler approach is allowed by the specification:
```
Which operations are cancelable is implementation-defined.
```
http://pubs.opengroup.org/onlinepubs/009695399/functions/aio_cancel.html
The only programs on my system that are capable of using `aio_cancel()`
are QEMU, beecrypt and fio use it according to a recursive grep of my
system's `/usr/src/debug`. That suggests that `aio_cancel()` users are
rare. Implementing aio_cancel() is left to a future date when it is
clear that there are consumers that benefit from its implementation to
justify the work.
Lastly, it is important to know that handling of the iovec updates differs
between Illumos and Linux in the implementation of read/write. On Linux,
it is the VFS' responsibility whle on Illumos, it is the filesystem's
responsibility. We take the intermediate solution of copying the iovec
so that the ZFS code can update it like on Solaris while leaving the
originals alone. This imposes some overhead. We could always revisit
this should profiling show that the allocations are a problem.
Signed-off-by: Richard Yao <ryao@gentoo.org>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Closes #223
Closes #2373
2014-08-04 11:09:32 +00:00
|
|
|
loff_t pos = 0;
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2013-10-28 16:07:00 +00:00
|
|
|
/*
|
|
|
|
* Lookup the xattr directory. When we're adding an entry pass
|
|
|
|
* CREATE_XATTR_DIR to ensure the xattr directory is created.
|
|
|
|
* When removing an entry this flag is not passed to avoid
|
|
|
|
* unnecessarily creating a new xattr directory.
|
|
|
|
*/
|
|
|
|
lookup_flags = LOOKUP_XATTR;
|
|
|
|
if (value != NULL)
|
|
|
|
lookup_flags |= CREATE_XATTR_DIR;
|
|
|
|
|
|
|
|
error = -zfs_lookup(ip, NULL, &dxip, lookup_flags, cr, NULL, NULL);
|
2011-01-26 20:10:01 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
2011-10-24 23:55:20 +00:00
|
|
|
/* Lookup a specific xattr name in the directory */
|
2011-01-26 20:10:01 +00:00
|
|
|
error = -zfs_lookup(dxip, (char *)name, &xip, 0, cr, NULL, NULL);
|
2011-10-24 23:55:20 +00:00
|
|
|
if (error && (error != -ENOENT))
|
|
|
|
goto out;
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
/* Remove a specific name xattr when value is set to NULL. */
|
|
|
|
if (value == NULL) {
|
|
|
|
if (xip)
|
|
|
|
error = -zfs_remove(dxip, (char *)name, cr);
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Lookup failed create a new xattr. */
|
|
|
|
if (xip == NULL) {
|
2013-11-01 19:26:11 +00:00
|
|
|
vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
|
2011-04-17 18:31:33 +00:00
|
|
|
vap->va_mode = xattr_mode;
|
2011-01-26 20:10:01 +00:00
|
|
|
vap->va_mask = ATTR_MODE;
|
2011-03-22 18:13:41 +00:00
|
|
|
vap->va_uid = crgetfsuid(cr);
|
|
|
|
vap->va_gid = crgetfsgid(cr);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
error = -zfs_create(dxip, (char *)name, vap, 0, 0644, &xip,
|
|
|
|
cr, 0, NULL);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(xip != NULL);
|
2011-04-17 18:31:33 +00:00
|
|
|
|
|
|
|
error = -zfs_freesp(ITOZ(xip), 0, 0, xattr_mode, TRUE);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
Linux AIO Support
nfsd uses do_readv_writev() to implement fops->read and fops->write.
do_readv_writev() will attempt to read/write using fops->aio_read and
fops->aio_write, but it will fallback to fops->read and fops->write when
AIO is not available. However, the fallback will perform a call for each
individual data page. Since our default recordsize is 128KB, sequential
operations on NFS will generate 32 DMU transactions where only 1
transaction was needed. That was unnecessary overhead and we implement
fops->aio_read and fops->aio_write to eliminate it.
ZFS originated in OpenSolaris, where the AIO API is entirely implemented
in userland's libc by intelligently mapping them to VOP_WRITE, VOP_READ
and VOP_FSYNC. Linux implements AIO inside the kernel itself. Linux
filesystems therefore must implement their own AIO logic and nearly all
of them implement fops->aio_write synchronously. Consequently, they do
not implement aio_fsync(). However, since the ZPL works by mapping
Linux's VFS calls to the functions implementing Illumos' VFS operations,
we instead implement AIO in the kernel by mapping the operations to the
VOP_READ, VOP_WRITE and VOP_FSYNC equivalents. We therefore implement
fops->aio_fsync.
One might be inclined to make our fops->aio_write implementation
synchronous to make software that expects this behavior safe. However,
there are several reasons not to do this:
1. Other platforms do not implement aio_write() synchronously and since
the majority of userland software using AIO should be cross platform,
expectations of synchronous behavior should not be a problem.
2. We would hurt the performance of programs that use POSIX interfaces
properly while simultaneously encouraging the creation of more
non-compliant software.
3. The broader community concluded that userland software should be
patched to properly use POSIX interfaces instead of implementing hacks
in filesystems to cater to broken software. This concept is best
described as the O_PONIES debate.
4. Making an asynchronous write synchronous is non sequitur.
Any software dependent on synchronous aio_write behavior will suffer
data loss on ZFSOnLinux in a kernel panic / system failure of at most
zfs_txg_timeout seconds, which by default is 5 seconds. This seems like
a reasonable consequence of using non-compliant software.
It should be noted that this is also a problem in the kernel itself
where nfsd does not pass O_SYNC on files opened with it and instead
relies on a open()/write()/close() to enforce synchronous behavior when
the flush is only guarenteed on last close.
Exporting any filesystem that does not implement AIO via NFS risks data
loss in the event of a kernel panic / system failure when something else
is also accessing the file. Exporting any file system that implements
AIO the way this patch does bears similar risk. However, it seems
reasonable to forgo crippling our AIO implementation in favor of
developing patches to fix this problem in Linux's nfsd for the reasons
stated earlier. In the interim, the risk will remain. Failing to
implement AIO will not change the problem that nfsd created, so there is
no reason for nfsd's mistake to block our implementation of AIO.
It also should be noted that `aio_cancel()` will always return
`AIO_NOTCANCELED` under this implementation. It is possible to implement
aio_cancel by deferring work to taskqs and use `kiocb_set_cancel_fn()`
to set a callback function for cancelling work sent to taskqs, but the
simpler approach is allowed by the specification:
```
Which operations are cancelable is implementation-defined.
```
http://pubs.opengroup.org/onlinepubs/009695399/functions/aio_cancel.html
The only programs on my system that are capable of using `aio_cancel()`
are QEMU, beecrypt and fio use it according to a recursive grep of my
system's `/usr/src/debug`. That suggests that `aio_cancel()` users are
rare. Implementing aio_cancel() is left to a future date when it is
clear that there are consumers that benefit from its implementation to
justify the work.
Lastly, it is important to know that handling of the iovec updates differs
between Illumos and Linux in the implementation of read/write. On Linux,
it is the VFS' responsibility whle on Illumos, it is the filesystem's
responsibility. We take the intermediate solution of copying the iovec
so that the ZFS code can update it like on Solaris while leaving the
originals alone. This imposes some overhead. We could always revisit
this should profiling show that the allocations are a problem.
Signed-off-by: Richard Yao <ryao@gentoo.org>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Closes #223
Closes #2373
2014-08-04 11:09:32 +00:00
|
|
|
wrote = zpl_write_common(xip, value, size, &pos, UIO_SYSSPACE, 0, cr);
|
2011-01-26 20:10:01 +00:00
|
|
|
if (wrote < 0)
|
|
|
|
error = wrote;
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (vap)
|
2013-11-01 19:26:11 +00:00
|
|
|
kmem_free(vap, sizeof (vattr_t));
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
if (xip)
|
|
|
|
iput(xip);
|
|
|
|
|
|
|
|
if (dxip)
|
|
|
|
iput(dxip);
|
|
|
|
|
|
|
|
if (error == -ENOENT)
|
|
|
|
error = -ENODATA;
|
|
|
|
|
|
|
|
ASSERT3S(error, <=, 0);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-10-24 23:55:20 +00:00
|
|
|
static int
|
|
|
|
zpl_xattr_set_sa(struct inode *ip, const char *name, const void *value,
|
|
|
|
size_t size, int flags, cred_t *cr)
|
|
|
|
{
|
|
|
|
znode_t *zp = ITOZ(ip);
|
|
|
|
nvlist_t *nvl;
|
|
|
|
size_t sa_size;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
ASSERT(zp->z_xattr_cached);
|
|
|
|
nvl = zp->z_xattr_cached;
|
|
|
|
|
|
|
|
if (value == NULL) {
|
|
|
|
error = -nvlist_remove(nvl, name, DATA_TYPE_BYTE_ARRAY);
|
|
|
|
if (error == -ENOENT)
|
|
|
|
error = zpl_xattr_set_dir(ip, name, NULL, 0, flags, cr);
|
|
|
|
} else {
|
|
|
|
/* Limited to 32k to keep nvpair memory allocations small */
|
|
|
|
if (size > DXATTR_MAX_ENTRY_SIZE)
|
|
|
|
return (-EFBIG);
|
|
|
|
|
|
|
|
/* Prevent the DXATTR SA from consuming the entire SA region */
|
|
|
|
error = -nvlist_size(nvl, &sa_size, NV_ENCODE_XDR);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
if (sa_size > DXATTR_MAX_SA_SIZE)
|
|
|
|
return (-EFBIG);
|
|
|
|
|
|
|
|
error = -nvlist_add_byte_array(nvl, name,
|
|
|
|
(uchar_t *)value, size);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update the SA for additions, modifications, and removals. */
|
|
|
|
if (!error)
|
|
|
|
error = -zfs_sa_set_xattr(zp);
|
|
|
|
|
|
|
|
ASSERT3S(error, <=, 0);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_set(struct inode *ip, const char *name, const void *value,
|
|
|
|
size_t size, int flags)
|
|
|
|
{
|
|
|
|
znode_t *zp = ITOZ(ip);
|
|
|
|
zfs_sb_t *zsb = ZTOZSB(zp);
|
|
|
|
cred_t *cr = CRED();
|
2015-04-14 17:25:50 +00:00
|
|
|
fstrans_cookie_t cookie;
|
2011-10-24 23:55:20 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
crhold(cr);
|
2015-04-14 17:25:50 +00:00
|
|
|
cookie = spl_fstrans_mark();
|
2011-10-24 23:55:20 +00:00
|
|
|
rw_enter(&ITOZ(ip)->z_xattr_lock, RW_WRITER);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Before setting the xattr check to see if it already exists.
|
|
|
|
* This is done to ensure the following optional flags are honored.
|
|
|
|
*
|
|
|
|
* XATTR_CREATE: fail if xattr already exists
|
|
|
|
* XATTR_REPLACE: fail if xattr does not exist
|
|
|
|
*/
|
|
|
|
error = __zpl_xattr_get(ip, name, NULL, 0, cr);
|
|
|
|
if (error < 0) {
|
|
|
|
if (error != -ENODATA)
|
|
|
|
goto out;
|
|
|
|
|
2013-10-28 16:07:00 +00:00
|
|
|
if (flags & XATTR_REPLACE)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* The xattr to be removed already doesn't exist */
|
|
|
|
error = 0;
|
|
|
|
if (value == NULL)
|
2011-10-24 23:55:20 +00:00
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
error = -EEXIST;
|
|
|
|
if (flags & XATTR_CREATE)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Preferentially store the xattr as a SA for better performance */
|
|
|
|
if (zsb->z_use_sa && zsb->z_xattr_sa && zp->z_is_sa) {
|
|
|
|
error = zpl_xattr_set_sa(ip, name, value, size, flags, cr);
|
|
|
|
if (error == 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = zpl_xattr_set_dir(ip, name, value, size, flags, cr);
|
|
|
|
out:
|
|
|
|
rw_exit(&ITOZ(ip)->z_xattr_lock);
|
2015-04-14 17:25:50 +00:00
|
|
|
spl_fstrans_unmark(cookie);
|
2011-10-24 23:55:20 +00:00
|
|
|
crfree(cr);
|
|
|
|
ASSERT3S(error, <=, 0);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-01-26 20:10:01 +00:00
|
|
|
static int
|
2011-02-11 18:33:01 +00:00
|
|
|
__zpl_xattr_user_get(struct inode *ip, const char *name,
|
2011-10-24 23:55:20 +00:00
|
|
|
void *value, size_t size)
|
2011-01-26 20:10:01 +00:00
|
|
|
{
|
|
|
|
char *xattr_name;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (strcmp(name, "") == 0)
|
2013-11-01 19:26:11 +00:00
|
|
|
return (-EINVAL);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2011-05-19 18:44:07 +00:00
|
|
|
if (!(ITOZSB(ip)->z_flags & ZSB_XATTR))
|
2013-11-01 19:26:11 +00:00
|
|
|
return (-EOPNOTSUPP);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
xattr_name = kmem_asprintf("%s%s", XATTR_USER_PREFIX, name);
|
2011-10-24 23:55:20 +00:00
|
|
|
error = zpl_xattr_get(ip, xattr_name, value, size);
|
2011-01-26 20:10:01 +00:00
|
|
|
strfree(xattr_name);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
2011-02-11 18:33:01 +00:00
|
|
|
ZPL_XATTR_GET_WRAPPER(zpl_xattr_user_get);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
static int
|
2011-02-11 18:33:01 +00:00
|
|
|
__zpl_xattr_user_set(struct inode *ip, const char *name,
|
2011-01-26 20:10:01 +00:00
|
|
|
const void *value, size_t size, int flags)
|
|
|
|
{
|
|
|
|
char *xattr_name;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (strcmp(name, "") == 0)
|
2013-11-01 19:26:11 +00:00
|
|
|
return (-EINVAL);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2011-05-19 18:44:07 +00:00
|
|
|
if (!(ITOZSB(ip)->z_flags & ZSB_XATTR))
|
2013-11-01 19:26:11 +00:00
|
|
|
return (-EOPNOTSUPP);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
xattr_name = kmem_asprintf("%s%s", XATTR_USER_PREFIX, name);
|
|
|
|
error = zpl_xattr_set(ip, xattr_name, value, size, flags);
|
|
|
|
strfree(xattr_name);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
2011-02-11 18:33:01 +00:00
|
|
|
ZPL_XATTR_SET_WRAPPER(zpl_xattr_user_set);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2011-02-11 00:16:52 +00:00
|
|
|
xattr_handler_t zpl_xattr_user_handler = {
|
2011-01-26 20:10:01 +00:00
|
|
|
.prefix = XATTR_USER_PREFIX,
|
|
|
|
.get = zpl_xattr_user_get,
|
|
|
|
.set = zpl_xattr_user_set,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
2011-02-11 18:33:01 +00:00
|
|
|
__zpl_xattr_trusted_get(struct inode *ip, const char *name,
|
2011-10-24 23:55:20 +00:00
|
|
|
void *value, size_t size)
|
2011-01-26 20:10:01 +00:00
|
|
|
{
|
|
|
|
char *xattr_name;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
2013-11-01 19:26:11 +00:00
|
|
|
return (-EACCES);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
if (strcmp(name, "") == 0)
|
2013-11-01 19:26:11 +00:00
|
|
|
return (-EINVAL);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
xattr_name = kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX, name);
|
2011-10-24 23:55:20 +00:00
|
|
|
error = zpl_xattr_get(ip, xattr_name, value, size);
|
2011-01-26 20:10:01 +00:00
|
|
|
strfree(xattr_name);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
2011-02-11 18:33:01 +00:00
|
|
|
ZPL_XATTR_GET_WRAPPER(zpl_xattr_trusted_get);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
static int
|
2011-02-11 18:33:01 +00:00
|
|
|
__zpl_xattr_trusted_set(struct inode *ip, const char *name,
|
2011-01-26 20:10:01 +00:00
|
|
|
const void *value, size_t size, int flags)
|
|
|
|
{
|
|
|
|
char *xattr_name;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
2013-11-01 19:26:11 +00:00
|
|
|
return (-EACCES);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
if (strcmp(name, "") == 0)
|
2013-11-01 19:26:11 +00:00
|
|
|
return (-EINVAL);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
xattr_name = kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX, name);
|
|
|
|
error = zpl_xattr_set(ip, xattr_name, value, size, flags);
|
|
|
|
strfree(xattr_name);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
2011-02-11 18:33:01 +00:00
|
|
|
ZPL_XATTR_SET_WRAPPER(zpl_xattr_trusted_set);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2011-02-11 00:16:52 +00:00
|
|
|
xattr_handler_t zpl_xattr_trusted_handler = {
|
2011-01-26 20:10:01 +00:00
|
|
|
.prefix = XATTR_TRUSTED_PREFIX,
|
|
|
|
.get = zpl_xattr_trusted_get,
|
|
|
|
.set = zpl_xattr_trusted_set,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
2011-02-11 18:33:01 +00:00
|
|
|
__zpl_xattr_security_get(struct inode *ip, const char *name,
|
2011-10-24 23:55:20 +00:00
|
|
|
void *value, size_t size)
|
2011-01-26 20:10:01 +00:00
|
|
|
{
|
|
|
|
char *xattr_name;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (strcmp(name, "") == 0)
|
2013-11-01 19:26:11 +00:00
|
|
|
return (-EINVAL);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
xattr_name = kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX, name);
|
2011-10-24 23:55:20 +00:00
|
|
|
error = zpl_xattr_get(ip, xattr_name, value, size);
|
2011-01-26 20:10:01 +00:00
|
|
|
strfree(xattr_name);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
2011-02-11 18:33:01 +00:00
|
|
|
ZPL_XATTR_GET_WRAPPER(zpl_xattr_security_get);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
static int
|
2011-02-11 18:33:01 +00:00
|
|
|
__zpl_xattr_security_set(struct inode *ip, const char *name,
|
2011-01-26 20:10:01 +00:00
|
|
|
const void *value, size_t size, int flags)
|
|
|
|
{
|
|
|
|
char *xattr_name;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (strcmp(name, "") == 0)
|
2013-11-01 19:26:11 +00:00
|
|
|
return (-EINVAL);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
|
|
|
xattr_name = kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX, name);
|
|
|
|
error = zpl_xattr_set(ip, xattr_name, value, size, flags);
|
|
|
|
strfree(xattr_name);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
2011-02-11 18:33:01 +00:00
|
|
|
ZPL_XATTR_SET_WRAPPER(zpl_xattr_security_set);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2012-01-12 21:59:44 +00:00
|
|
|
#ifdef HAVE_CALLBACK_SECURITY_INODE_INIT_SECURITY
|
|
|
|
static int
|
|
|
|
__zpl_xattr_security_init(struct inode *ip, const struct xattr *xattrs,
|
|
|
|
void *fs_info)
|
|
|
|
{
|
|
|
|
const struct xattr *xattr;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
for (xattr = xattrs; xattr->name != NULL; xattr++) {
|
|
|
|
error = __zpl_xattr_security_set(ip,
|
|
|
|
xattr->name, xattr->value, xattr->value_len, 0);
|
|
|
|
|
|
|
|
if (error < 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-01-05 20:27:36 +00:00
|
|
|
return (error);
|
2012-01-12 21:59:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
zpl_xattr_security_init(struct inode *ip, struct inode *dip,
|
|
|
|
const struct qstr *qstr)
|
|
|
|
{
|
|
|
|
return security_inode_init_security(ip, dip, qstr,
|
|
|
|
&__zpl_xattr_security_init, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
2011-01-26 20:10:01 +00:00
|
|
|
int
|
2011-05-19 19:47:32 +00:00
|
|
|
zpl_xattr_security_init(struct inode *ip, struct inode *dip,
|
|
|
|
const struct qstr *qstr)
|
2011-01-26 20:10:01 +00:00
|
|
|
{
|
2012-01-05 20:27:36 +00:00
|
|
|
int error;
|
|
|
|
size_t len;
|
|
|
|
void *value;
|
|
|
|
char *name;
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2012-01-05 20:27:36 +00:00
|
|
|
error = zpl_security_inode_init_security(ip, dip, qstr,
|
2013-11-01 19:26:11 +00:00
|
|
|
&name, &value, &len);
|
2012-01-05 20:27:36 +00:00
|
|
|
if (error) {
|
|
|
|
if (error == -EOPNOTSUPP)
|
2013-11-01 19:26:11 +00:00
|
|
|
return (0);
|
|
|
|
|
2012-01-05 20:27:36 +00:00
|
|
|
return (error);
|
|
|
|
}
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2011-02-11 18:33:01 +00:00
|
|
|
error = __zpl_xattr_security_set(ip, name, value, len, 0);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2012-01-05 20:27:36 +00:00
|
|
|
kfree(name);
|
|
|
|
kfree(value);
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2012-01-05 20:27:36 +00:00
|
|
|
return (error);
|
2011-01-26 20:10:01 +00:00
|
|
|
}
|
2012-01-12 21:59:44 +00:00
|
|
|
#endif /* HAVE_CALLBACK_SECURITY_INODE_INIT_SECURITY */
|
2011-01-26 20:10:01 +00:00
|
|
|
|
2011-02-11 00:16:52 +00:00
|
|
|
xattr_handler_t zpl_xattr_security_handler = {
|
2011-01-26 20:10:01 +00:00
|
|
|
.prefix = XATTR_SECURITY_PREFIX,
|
|
|
|
.get = zpl_xattr_security_get,
|
|
|
|
.set = zpl_xattr_security_set,
|
|
|
|
};
|
|
|
|
|
2013-11-02 23:40:26 +00:00
|
|
|
#ifdef CONFIG_FS_POSIX_ACL
|
|
|
|
|
2013-10-28 16:22:15 +00:00
|
|
|
int
|
|
|
|
zpl_set_acl(struct inode *ip, int type, struct posix_acl *acl)
|
|
|
|
{
|
|
|
|
struct super_block *sb = ITOZSB(ip)->z_sb;
|
|
|
|
char *name, *value = NULL;
|
|
|
|
int error = 0;
|
|
|
|
size_t size = 0;
|
|
|
|
|
|
|
|
if (S_ISLNK(ip->i_mode))
|
|
|
|
return (-EOPNOTSUPP);
|
|
|
|
|
2013-11-01 19:26:11 +00:00
|
|
|
switch (type) {
|
2013-10-28 16:22:15 +00:00
|
|
|
case ACL_TYPE_ACCESS:
|
|
|
|
name = POSIX_ACL_XATTR_ACCESS;
|
|
|
|
if (acl) {
|
|
|
|
zpl_equivmode_t mode = ip->i_mode;
|
|
|
|
error = posix_acl_equiv_mode(acl, &mode);
|
|
|
|
if (error < 0) {
|
|
|
|
return (error);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The mode bits will have been set by
|
|
|
|
* ->zfs_setattr()->zfs_acl_chmod_setattr()
|
|
|
|
* using the ZFS ACL conversion. If they
|
|
|
|
* differ from the Posix ACL conversion dirty
|
|
|
|
* the inode to write the Posix mode bits.
|
|
|
|
*/
|
|
|
|
if (ip->i_mode != mode) {
|
|
|
|
ip->i_mode = mode;
|
|
|
|
ip->i_ctime = current_fs_time(sb);
|
2014-07-15 20:29:57 +00:00
|
|
|
zfs_mark_inode_dirty(ip);
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (error == 0)
|
|
|
|
acl = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACL_TYPE_DEFAULT:
|
|
|
|
name = POSIX_ACL_XATTR_DEFAULT;
|
|
|
|
if (!S_ISDIR(ip->i_mode))
|
|
|
|
return (acl ? -EACCES : 0);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return (-EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (acl) {
|
|
|
|
size = posix_acl_xattr_size(acl->a_count);
|
|
|
|
value = kmem_alloc(size, KM_SLEEP);
|
|
|
|
|
|
|
|
error = zpl_acl_to_xattr(acl, value, size);
|
|
|
|
if (error < 0) {
|
|
|
|
kmem_free(value, size);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
error = zpl_xattr_set(ip, name, value, size, 0);
|
|
|
|
if (value)
|
|
|
|
kmem_free(value, size);
|
|
|
|
|
|
|
|
if (!error) {
|
|
|
|
if (acl)
|
|
|
|
zpl_set_cached_acl(ip, type, acl);
|
|
|
|
else
|
|
|
|
zpl_forget_cached_acl(ip, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct posix_acl *
|
|
|
|
zpl_get_acl(struct inode *ip, int type)
|
|
|
|
{
|
|
|
|
struct posix_acl *acl;
|
|
|
|
void *value = NULL;
|
|
|
|
char *name;
|
|
|
|
int size;
|
|
|
|
|
|
|
|
#ifdef HAVE_POSIX_ACL_CACHING
|
|
|
|
acl = get_cached_acl(ip, type);
|
|
|
|
if (acl != ACL_NOT_CACHED)
|
|
|
|
return (acl);
|
|
|
|
#endif /* HAVE_POSIX_ACL_CACHING */
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case ACL_TYPE_ACCESS:
|
|
|
|
name = POSIX_ACL_XATTR_ACCESS;
|
|
|
|
break;
|
|
|
|
case ACL_TYPE_DEFAULT:
|
|
|
|
name = POSIX_ACL_XATTR_DEFAULT;
|
|
|
|
break;
|
|
|
|
default:
|
2013-11-01 19:26:11 +00:00
|
|
|
return (ERR_PTR(-EINVAL));
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
size = zpl_xattr_get(ip, name, NULL, 0);
|
|
|
|
if (size > 0) {
|
2014-11-21 00:09:39 +00:00
|
|
|
value = kmem_alloc(size, KM_SLEEP);
|
2013-10-28 16:22:15 +00:00
|
|
|
size = zpl_xattr_get(ip, name, value, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size > 0) {
|
|
|
|
acl = zpl_acl_from_xattr(value, size);
|
|
|
|
} else if (size == -ENODATA || size == -ENOSYS) {
|
|
|
|
acl = NULL;
|
|
|
|
} else {
|
|
|
|
acl = ERR_PTR(-EIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size > 0)
|
|
|
|
kmem_free(value, size);
|
|
|
|
|
|
|
|
if (!IS_ERR(acl))
|
|
|
|
zpl_set_cached_acl(ip, type, acl);
|
|
|
|
|
|
|
|
return (acl);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if !defined(HAVE_GET_ACL)
|
|
|
|
static int
|
|
|
|
__zpl_check_acl(struct inode *ip, int mask)
|
|
|
|
{
|
|
|
|
struct posix_acl *acl;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
acl = zpl_get_acl(ip, ACL_TYPE_ACCESS);
|
|
|
|
if (IS_ERR(acl))
|
|
|
|
return (PTR_ERR(acl));
|
|
|
|
|
|
|
|
if (acl) {
|
|
|
|
error = posix_acl_permission(ip, acl, mask);
|
|
|
|
zpl_posix_acl_release(acl);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (-EAGAIN);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(HAVE_CHECK_ACL_WITH_FLAGS)
|
|
|
|
int
|
|
|
|
zpl_check_acl(struct inode *ip, int mask, unsigned int flags)
|
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
return (__zpl_check_acl(ip, mask));
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
#elif defined(HAVE_CHECK_ACL)
|
|
|
|
int
|
|
|
|
zpl_check_acl(struct inode *ip, int mask)
|
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
return (__zpl_check_acl(ip, mask));
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
#elif defined(HAVE_PERMISSION_WITH_NAMEIDATA)
|
|
|
|
int
|
|
|
|
zpl_permission(struct inode *ip, int mask, struct nameidata *nd)
|
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
return (generic_permission(ip, mask, __zpl_check_acl));
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
#elif defined(HAVE_PERMISSION)
|
|
|
|
int
|
|
|
|
zpl_permission(struct inode *ip, int mask)
|
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
return (generic_permission(ip, mask, __zpl_check_acl));
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
#endif /* HAVE_CHECK_ACL | HAVE_PERMISSION */
|
|
|
|
#endif /* !HAVE_GET_ACL */
|
|
|
|
|
|
|
|
int
|
|
|
|
zpl_init_acl(struct inode *ip, struct inode *dir)
|
|
|
|
{
|
|
|
|
struct posix_acl *acl = NULL;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIXACL)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
if (!S_ISLNK(ip->i_mode)) {
|
|
|
|
if (ITOZSB(ip)->z_acl_type == ZFS_ACLTYPE_POSIXACL) {
|
|
|
|
acl = zpl_get_acl(dir, ACL_TYPE_DEFAULT);
|
|
|
|
if (IS_ERR(acl))
|
|
|
|
return (PTR_ERR(acl));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!acl) {
|
|
|
|
ip->i_mode &= ~current_umask();
|
|
|
|
ip->i_ctime = current_fs_time(ITOZSB(ip)->z_sb);
|
2014-07-15 20:29:57 +00:00
|
|
|
zfs_mark_inode_dirty(ip);
|
2013-10-28 16:22:15 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ITOZSB(ip)->z_acl_type == ZFS_ACLTYPE_POSIXACL) && acl) {
|
|
|
|
umode_t mode;
|
|
|
|
|
|
|
|
if (S_ISDIR(ip->i_mode)) {
|
|
|
|
error = zpl_set_acl(ip, ACL_TYPE_DEFAULT, acl);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mode = ip->i_mode;
|
2014-03-28 04:59:36 +00:00
|
|
|
error = __posix_acl_create(&acl, GFP_KERNEL, &mode);
|
2013-10-28 16:22:15 +00:00
|
|
|
if (error >= 0) {
|
|
|
|
ip->i_mode = mode;
|
2014-07-15 20:29:57 +00:00
|
|
|
zfs_mark_inode_dirty(ip);
|
2013-10-28 16:22:15 +00:00
|
|
|
if (error > 0)
|
|
|
|
error = zpl_set_acl(ip, ACL_TYPE_ACCESS, acl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
zpl_posix_acl_release(acl);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
zpl_chmod_acl(struct inode *ip)
|
|
|
|
{
|
|
|
|
struct posix_acl *acl;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIXACL)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
if (S_ISLNK(ip->i_mode))
|
|
|
|
return (-EOPNOTSUPP);
|
|
|
|
|
|
|
|
acl = zpl_get_acl(ip, ACL_TYPE_ACCESS);
|
|
|
|
if (IS_ERR(acl) || !acl)
|
|
|
|
return (PTR_ERR(acl));
|
|
|
|
|
2014-03-28 04:59:36 +00:00
|
|
|
error = __posix_acl_chmod(&acl, GFP_KERNEL, ip->i_mode);
|
2013-10-28 16:22:15 +00:00
|
|
|
if (!error)
|
2013-11-01 19:26:11 +00:00
|
|
|
error = zpl_set_acl(ip, ACL_TYPE_ACCESS, acl);
|
2013-10-28 16:22:15 +00:00
|
|
|
|
|
|
|
zpl_posix_acl_release(acl);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
zpl_xattr_acl_list(struct inode *ip, char *list, size_t list_size,
|
|
|
|
const char *name, size_t name_len, int type)
|
|
|
|
{
|
|
|
|
char *xattr_name;
|
|
|
|
size_t xattr_size;
|
|
|
|
|
|
|
|
if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIXACL)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case ACL_TYPE_ACCESS:
|
|
|
|
xattr_name = POSIX_ACL_XATTR_ACCESS;
|
2013-11-01 19:26:11 +00:00
|
|
|
xattr_size = sizeof (xattr_name);
|
2013-10-28 16:22:15 +00:00
|
|
|
break;
|
|
|
|
case ACL_TYPE_DEFAULT:
|
|
|
|
xattr_name = POSIX_ACL_XATTR_DEFAULT;
|
2013-11-01 19:26:11 +00:00
|
|
|
xattr_size = sizeof (xattr_name);
|
2013-10-28 16:22:15 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (list && xattr_size <= list_size)
|
|
|
|
memcpy(list, xattr_name, xattr_size);
|
|
|
|
|
|
|
|
return (xattr_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_DENTRY_XATTR_LIST
|
|
|
|
static size_t
|
|
|
|
zpl_xattr_acl_list_access(struct dentry *dentry, char *list,
|
|
|
|
size_t list_size, const char *name, size_t name_len, int type)
|
|
|
|
{
|
|
|
|
ASSERT3S(type, ==, ACL_TYPE_ACCESS);
|
|
|
|
return zpl_xattr_acl_list(dentry->d_inode,
|
|
|
|
list, list_size, name, name_len, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
zpl_xattr_acl_list_default(struct dentry *dentry, char *list,
|
|
|
|
size_t list_size, const char *name, size_t name_len, int type)
|
|
|
|
{
|
|
|
|
ASSERT3S(type, ==, ACL_TYPE_DEFAULT);
|
|
|
|
return zpl_xattr_acl_list(dentry->d_inode,
|
|
|
|
list, list_size, name, name_len, type);
|
|
|
|
}
|
|
|
|
|
2015-11-23 23:06:46 +00:00
|
|
|
#elif defined(HAVE_HANDLER_XATTR_LIST)
|
|
|
|
static size_t
|
|
|
|
zpl_xattr_acl_list_access(const struct xattr_handler *handler,
|
|
|
|
struct dentry *dentry, char *list, size_t list_size, const char *name,
|
|
|
|
size_t name_len)
|
|
|
|
{
|
|
|
|
int type = handler->flags;
|
|
|
|
ASSERT3S(type, ==, ACL_TYPE_ACCESS);
|
|
|
|
return zpl_xattr_acl_list(dentry->d_inode,
|
|
|
|
list, list_size, name, name_len, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
zpl_xattr_acl_list_default(const struct xattr_handler *handler,
|
|
|
|
struct dentry *dentry, char *list, size_t list_size, const char *name,
|
|
|
|
size_t name_len)
|
|
|
|
{
|
|
|
|
int type = handler->flags;
|
|
|
|
ASSERT3S(type, ==, ACL_TYPE_DEFAULT);
|
|
|
|
return zpl_xattr_acl_list(dentry->d_inode,
|
|
|
|
list, list_size, name, name_len, type);
|
|
|
|
}
|
|
|
|
|
2013-10-28 16:22:15 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
zpl_xattr_acl_list_access(struct inode *ip, char *list, size_t list_size,
|
|
|
|
const char *name, size_t name_len)
|
|
|
|
{
|
|
|
|
return zpl_xattr_acl_list(ip,
|
|
|
|
list, list_size, name, name_len, ACL_TYPE_ACCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
zpl_xattr_acl_list_default(struct inode *ip, char *list, size_t list_size,
|
|
|
|
const char *name, size_t name_len)
|
|
|
|
{
|
|
|
|
return zpl_xattr_acl_list(ip,
|
|
|
|
list, list_size, name, name_len, ACL_TYPE_DEFAULT);
|
|
|
|
}
|
|
|
|
#endif /* HAVE_DENTRY_XATTR_LIST */
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_get(struct inode *ip, const char *name,
|
|
|
|
void *buffer, size_t size, int type)
|
|
|
|
{
|
|
|
|
struct posix_acl *acl;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (strcmp(name, "") != 0)
|
|
|
|
return (-EINVAL);
|
|
|
|
|
|
|
|
if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIXACL)
|
|
|
|
return (-EOPNOTSUPP);
|
|
|
|
|
|
|
|
acl = zpl_get_acl(ip, type);
|
|
|
|
if (IS_ERR(acl))
|
|
|
|
return (PTR_ERR(acl));
|
|
|
|
if (acl == NULL)
|
|
|
|
return (-ENODATA);
|
|
|
|
|
|
|
|
error = zpl_acl_to_xattr(acl, buffer, size);
|
|
|
|
zpl_posix_acl_release(acl);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_DENTRY_XATTR_GET
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_get_access(struct dentry *dentry, const char *name,
|
|
|
|
void *buffer, size_t size, int type)
|
|
|
|
{
|
|
|
|
ASSERT3S(type, ==, ACL_TYPE_ACCESS);
|
2013-11-01 19:26:11 +00:00
|
|
|
return (zpl_xattr_acl_get(dentry->d_inode, name, buffer, size, type));
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_get_default(struct dentry *dentry, const char *name,
|
|
|
|
void *buffer, size_t size, int type)
|
|
|
|
{
|
|
|
|
ASSERT3S(type, ==, ACL_TYPE_DEFAULT);
|
2013-11-01 19:26:11 +00:00
|
|
|
return (zpl_xattr_acl_get(dentry->d_inode, name, buffer, size, type));
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2015-11-23 23:06:46 +00:00
|
|
|
#elif defined(HAVE_HANDLER_XATTR_GET)
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_get_access(const struct xattr_handler *handler,
|
|
|
|
struct dentry *dentry, const char *name, void *buffer, size_t size)
|
|
|
|
{
|
|
|
|
int type = handler->flags;
|
|
|
|
ASSERT3S(type, ==, ACL_TYPE_ACCESS);
|
|
|
|
return (zpl_xattr_acl_get(dentry->d_inode, name, buffer, size, type));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_get_default(const struct xattr_handler *handler,
|
|
|
|
struct dentry *dentry, const char *name, void *buffer, size_t size)
|
|
|
|
{
|
|
|
|
int type = handler->flags;
|
|
|
|
ASSERT3S(type, ==, ACL_TYPE_DEFAULT);
|
|
|
|
return (zpl_xattr_acl_get(dentry->d_inode, name, buffer, size, type));
|
|
|
|
}
|
|
|
|
|
2013-10-28 16:22:15 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_get_access(struct inode *ip, const char *name,
|
|
|
|
void *buffer, size_t size)
|
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
return (zpl_xattr_acl_get(ip, name, buffer, size, ACL_TYPE_ACCESS));
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_get_default(struct inode *ip, const char *name,
|
|
|
|
void *buffer, size_t size)
|
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
return (zpl_xattr_acl_get(ip, name, buffer, size, ACL_TYPE_DEFAULT));
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
#endif /* HAVE_DENTRY_XATTR_GET */
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_set(struct inode *ip, const char *name,
|
|
|
|
const void *value, size_t size, int flags, int type)
|
|
|
|
{
|
|
|
|
struct posix_acl *acl;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (strcmp(name, "") != 0)
|
|
|
|
return (-EINVAL);
|
|
|
|
|
|
|
|
if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIXACL)
|
|
|
|
return (-EOPNOTSUPP);
|
|
|
|
|
|
|
|
if (!zpl_inode_owner_or_capable(ip))
|
|
|
|
return (-EPERM);
|
|
|
|
|
|
|
|
if (value) {
|
|
|
|
acl = zpl_acl_from_xattr(value, size);
|
|
|
|
if (IS_ERR(acl))
|
|
|
|
return (PTR_ERR(acl));
|
|
|
|
else if (acl) {
|
|
|
|
error = posix_acl_valid(acl);
|
|
|
|
if (error) {
|
|
|
|
zpl_posix_acl_release(acl);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
acl = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = zpl_set_acl(ip, type, acl);
|
|
|
|
zpl_posix_acl_release(acl);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_DENTRY_XATTR_SET
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_set_access(struct dentry *dentry, const char *name,
|
|
|
|
const void *value, size_t size, int flags, int type)
|
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
ASSERT3S(type, ==, ACL_TYPE_ACCESS);
|
|
|
|
return (zpl_xattr_acl_set(dentry->d_inode,
|
|
|
|
name, value, size, flags, type));
|
2013-10-28 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_set_default(struct dentry *dentry, const char *name,
|
2013-11-01 19:26:11 +00:00
|
|
|
const void *value, size_t size, int flags, int type)
|
2013-10-28 16:22:15 +00:00
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
ASSERT3S(type, ==, ACL_TYPE_DEFAULT);
|
|
|
|
return zpl_xattr_acl_set(dentry->d_inode,
|
2013-10-28 16:22:15 +00:00
|
|
|
name, value, size, flags, type);
|
|
|
|
}
|
|
|
|
|
2015-11-23 23:06:46 +00:00
|
|
|
#elif defined(HAVE_HANDLER_XATTR_SET)
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_set_access(const struct xattr_handler *handler,
|
|
|
|
struct dentry *dentry, const char *name, const void *value, size_t size,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
int type = handler->flags;
|
|
|
|
ASSERT3S(type, ==, ACL_TYPE_ACCESS);
|
|
|
|
return (zpl_xattr_acl_set(dentry->d_inode,
|
|
|
|
name, value, size, flags, type));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_set_default(const struct xattr_handler *handler,
|
|
|
|
struct dentry *dentry, const char *name, const void *value, size_t size,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
int type = handler->flags;
|
|
|
|
ASSERT3S(type, ==, ACL_TYPE_DEFAULT);
|
|
|
|
return zpl_xattr_acl_set(dentry->d_inode,
|
|
|
|
name, value, size, flags, type);
|
|
|
|
}
|
|
|
|
|
2013-10-28 16:22:15 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_set_access(struct inode *ip, const char *name,
|
|
|
|
const void *value, size_t size, int flags)
|
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
return zpl_xattr_acl_set(ip,
|
2013-10-28 16:22:15 +00:00
|
|
|
name, value, size, flags, ACL_TYPE_ACCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zpl_xattr_acl_set_default(struct inode *ip, const char *name,
|
|
|
|
const void *value, size_t size, int flags)
|
|
|
|
{
|
2013-11-01 19:26:11 +00:00
|
|
|
return zpl_xattr_acl_set(ip,
|
2013-10-28 16:22:15 +00:00
|
|
|
name, value, size, flags, ACL_TYPE_DEFAULT);
|
|
|
|
}
|
|
|
|
#endif /* HAVE_DENTRY_XATTR_SET */
|
|
|
|
|
|
|
|
struct xattr_handler zpl_xattr_acl_access_handler =
|
|
|
|
{
|
|
|
|
.prefix = POSIX_ACL_XATTR_ACCESS,
|
|
|
|
.list = zpl_xattr_acl_list_access,
|
|
|
|
.get = zpl_xattr_acl_get_access,
|
|
|
|
.set = zpl_xattr_acl_set_access,
|
2015-11-23 23:06:46 +00:00
|
|
|
#if defined(HAVE_DENTRY_XATTR_LIST) || defined(HAVE_HANDLER_XATTR_LIST)
|
2013-10-28 16:22:15 +00:00
|
|
|
.flags = ACL_TYPE_ACCESS,
|
|
|
|
#endif /* HAVE_DENTRY_XATTR_LIST */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct xattr_handler zpl_xattr_acl_default_handler =
|
|
|
|
{
|
|
|
|
.prefix = POSIX_ACL_XATTR_DEFAULT,
|
|
|
|
.list = zpl_xattr_acl_list_default,
|
|
|
|
.get = zpl_xattr_acl_get_default,
|
|
|
|
.set = zpl_xattr_acl_set_default,
|
2015-11-23 23:06:46 +00:00
|
|
|
#if defined(HAVE_DENTRY_XATTR_LIST) || defined(HAVE_HANDLER_XATTR_LIST)
|
2013-10-28 16:22:15 +00:00
|
|
|
.flags = ACL_TYPE_DEFAULT,
|
|
|
|
#endif /* HAVE_DENTRY_XATTR_LIST */
|
|
|
|
};
|
|
|
|
|
2013-11-02 23:40:26 +00:00
|
|
|
#endif /* CONFIG_FS_POSIX_ACL */
|
|
|
|
|
2011-02-11 00:16:52 +00:00
|
|
|
xattr_handler_t *zpl_xattr_handlers[] = {
|
2011-01-26 20:10:01 +00:00
|
|
|
&zpl_xattr_security_handler,
|
|
|
|
&zpl_xattr_trusted_handler,
|
|
|
|
&zpl_xattr_user_handler,
|
2013-11-02 23:40:26 +00:00
|
|
|
#ifdef CONFIG_FS_POSIX_ACL
|
2011-01-26 20:10:01 +00:00
|
|
|
&zpl_xattr_acl_access_handler,
|
2012-01-05 20:27:36 +00:00
|
|
|
&zpl_xattr_acl_default_handler,
|
2013-11-02 23:40:26 +00:00
|
|
|
#endif /* CONFIG_FS_POSIX_ACL */
|
2012-03-14 19:36:49 +00:00
|
|
|
NULL
|
2011-01-26 20:10:01 +00:00
|
|
|
};
|