forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
363 lines
8.4 KiB
363 lines
8.4 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* Extended attribute handling for AFS. We use xattrs to get and set metadata |
|
* instead of providing pioctl(). |
|
* |
|
* Copyright (C) 2017 Red Hat, Inc. All Rights Reserved. |
|
* Written by David Howells ([email protected]) |
|
*/ |
|
|
|
#include <linux/slab.h> |
|
#include <linux/fs.h> |
|
#include <linux/xattr.h> |
|
#include "internal.h" |
|
|
|
/* |
|
* Deal with the result of a successful fetch ACL operation. |
|
*/ |
|
static void afs_acl_success(struct afs_operation *op) |
|
{ |
|
afs_vnode_commit_status(op, &op->file[0]); |
|
} |
|
|
|
static void afs_acl_put(struct afs_operation *op) |
|
{ |
|
kfree(op->acl); |
|
} |
|
|
|
static const struct afs_operation_ops afs_fetch_acl_operation = { |
|
.issue_afs_rpc = afs_fs_fetch_acl, |
|
.success = afs_acl_success, |
|
.put = afs_acl_put, |
|
}; |
|
|
|
/* |
|
* Get a file's ACL. |
|
*/ |
|
static int afs_xattr_get_acl(const struct xattr_handler *handler, |
|
struct dentry *dentry, |
|
struct inode *inode, const char *name, |
|
void *buffer, size_t size) |
|
{ |
|
struct afs_operation *op; |
|
struct afs_vnode *vnode = AFS_FS_I(inode); |
|
struct afs_acl *acl = NULL; |
|
int ret; |
|
|
|
op = afs_alloc_operation(NULL, vnode->volume); |
|
if (IS_ERR(op)) |
|
return -ENOMEM; |
|
|
|
afs_op_set_vnode(op, 0, vnode); |
|
op->ops = &afs_fetch_acl_operation; |
|
|
|
afs_begin_vnode_operation(op); |
|
afs_wait_for_operation(op); |
|
acl = op->acl; |
|
op->acl = NULL; |
|
ret = afs_put_operation(op); |
|
|
|
if (ret == 0) { |
|
ret = acl->size; |
|
if (size > 0) { |
|
if (acl->size <= size) |
|
memcpy(buffer, acl->data, acl->size); |
|
else |
|
ret = -ERANGE; |
|
} |
|
} |
|
|
|
kfree(acl); |
|
return ret; |
|
} |
|
|
|
static bool afs_make_acl(struct afs_operation *op, |
|
const void *buffer, size_t size) |
|
{ |
|
struct afs_acl *acl; |
|
|
|
acl = kmalloc(sizeof(*acl) + size, GFP_KERNEL); |
|
if (!acl) { |
|
afs_op_nomem(op); |
|
return false; |
|
} |
|
|
|
acl->size = size; |
|
memcpy(acl->data, buffer, size); |
|
op->acl = acl; |
|
return true; |
|
} |
|
|
|
static const struct afs_operation_ops afs_store_acl_operation = { |
|
.issue_afs_rpc = afs_fs_store_acl, |
|
.success = afs_acl_success, |
|
.put = afs_acl_put, |
|
}; |
|
|
|
/* |
|
* Set a file's AFS3 ACL. |
|
*/ |
|
static int afs_xattr_set_acl(const struct xattr_handler *handler, |
|
struct user_namespace *mnt_userns, |
|
struct dentry *dentry, |
|
struct inode *inode, const char *name, |
|
const void *buffer, size_t size, int flags) |
|
{ |
|
struct afs_operation *op; |
|
struct afs_vnode *vnode = AFS_FS_I(inode); |
|
|
|
if (flags == XATTR_CREATE) |
|
return -EINVAL; |
|
|
|
op = afs_alloc_operation(NULL, vnode->volume); |
|
if (IS_ERR(op)) |
|
return -ENOMEM; |
|
|
|
afs_op_set_vnode(op, 0, vnode); |
|
if (!afs_make_acl(op, buffer, size)) |
|
return afs_put_operation(op); |
|
|
|
op->ops = &afs_store_acl_operation; |
|
return afs_do_sync_operation(op); |
|
} |
|
|
|
static const struct xattr_handler afs_xattr_afs_acl_handler = { |
|
.name = "afs.acl", |
|
.get = afs_xattr_get_acl, |
|
.set = afs_xattr_set_acl, |
|
}; |
|
|
|
static const struct afs_operation_ops yfs_fetch_opaque_acl_operation = { |
|
.issue_yfs_rpc = yfs_fs_fetch_opaque_acl, |
|
.success = afs_acl_success, |
|
/* Don't free op->yacl in .put here */ |
|
}; |
|
|
|
/* |
|
* Get a file's YFS ACL. |
|
*/ |
|
static int afs_xattr_get_yfs(const struct xattr_handler *handler, |
|
struct dentry *dentry, |
|
struct inode *inode, const char *name, |
|
void *buffer, size_t size) |
|
{ |
|
struct afs_operation *op; |
|
struct afs_vnode *vnode = AFS_FS_I(inode); |
|
struct yfs_acl *yacl = NULL; |
|
char buf[16], *data; |
|
int which = 0, dsize, ret = -ENOMEM; |
|
|
|
if (strcmp(name, "acl") == 0) |
|
which = 0; |
|
else if (strcmp(name, "acl_inherited") == 0) |
|
which = 1; |
|
else if (strcmp(name, "acl_num_cleaned") == 0) |
|
which = 2; |
|
else if (strcmp(name, "vol_acl") == 0) |
|
which = 3; |
|
else |
|
return -EOPNOTSUPP; |
|
|
|
yacl = kzalloc(sizeof(struct yfs_acl), GFP_KERNEL); |
|
if (!yacl) |
|
goto error; |
|
|
|
if (which == 0) |
|
yacl->flags |= YFS_ACL_WANT_ACL; |
|
else if (which == 3) |
|
yacl->flags |= YFS_ACL_WANT_VOL_ACL; |
|
|
|
op = afs_alloc_operation(NULL, vnode->volume); |
|
if (IS_ERR(op)) |
|
goto error_yacl; |
|
|
|
afs_op_set_vnode(op, 0, vnode); |
|
op->yacl = yacl; |
|
op->ops = &yfs_fetch_opaque_acl_operation; |
|
|
|
afs_begin_vnode_operation(op); |
|
afs_wait_for_operation(op); |
|
ret = afs_put_operation(op); |
|
|
|
if (ret == 0) { |
|
switch (which) { |
|
case 0: |
|
data = yacl->acl->data; |
|
dsize = yacl->acl->size; |
|
break; |
|
case 1: |
|
data = buf; |
|
dsize = scnprintf(buf, sizeof(buf), "%u", yacl->inherit_flag); |
|
break; |
|
case 2: |
|
data = buf; |
|
dsize = scnprintf(buf, sizeof(buf), "%u", yacl->num_cleaned); |
|
break; |
|
case 3: |
|
data = yacl->vol_acl->data; |
|
dsize = yacl->vol_acl->size; |
|
break; |
|
default: |
|
ret = -EOPNOTSUPP; |
|
goto error_yacl; |
|
} |
|
|
|
ret = dsize; |
|
if (size > 0) { |
|
if (dsize <= size) |
|
memcpy(buffer, data, dsize); |
|
else |
|
ret = -ERANGE; |
|
} |
|
} else if (ret == -ENOTSUPP) { |
|
ret = -ENODATA; |
|
} |
|
|
|
error_yacl: |
|
yfs_free_opaque_acl(yacl); |
|
error: |
|
return ret; |
|
} |
|
|
|
static const struct afs_operation_ops yfs_store_opaque_acl2_operation = { |
|
.issue_yfs_rpc = yfs_fs_store_opaque_acl2, |
|
.success = afs_acl_success, |
|
.put = afs_acl_put, |
|
}; |
|
|
|
/* |
|
* Set a file's YFS ACL. |
|
*/ |
|
static int afs_xattr_set_yfs(const struct xattr_handler *handler, |
|
struct user_namespace *mnt_userns, |
|
struct dentry *dentry, |
|
struct inode *inode, const char *name, |
|
const void *buffer, size_t size, int flags) |
|
{ |
|
struct afs_operation *op; |
|
struct afs_vnode *vnode = AFS_FS_I(inode); |
|
int ret; |
|
|
|
if (flags == XATTR_CREATE || |
|
strcmp(name, "acl") != 0) |
|
return -EINVAL; |
|
|
|
op = afs_alloc_operation(NULL, vnode->volume); |
|
if (IS_ERR(op)) |
|
return -ENOMEM; |
|
|
|
afs_op_set_vnode(op, 0, vnode); |
|
if (!afs_make_acl(op, buffer, size)) |
|
return afs_put_operation(op); |
|
|
|
op->ops = &yfs_store_opaque_acl2_operation; |
|
ret = afs_do_sync_operation(op); |
|
if (ret == -ENOTSUPP) |
|
ret = -ENODATA; |
|
return ret; |
|
} |
|
|
|
static const struct xattr_handler afs_xattr_yfs_handler = { |
|
.prefix = "afs.yfs.", |
|
.get = afs_xattr_get_yfs, |
|
.set = afs_xattr_set_yfs, |
|
}; |
|
|
|
/* |
|
* Get the name of the cell on which a file resides. |
|
*/ |
|
static int afs_xattr_get_cell(const struct xattr_handler *handler, |
|
struct dentry *dentry, |
|
struct inode *inode, const char *name, |
|
void *buffer, size_t size) |
|
{ |
|
struct afs_vnode *vnode = AFS_FS_I(inode); |
|
struct afs_cell *cell = vnode->volume->cell; |
|
size_t namelen; |
|
|
|
namelen = cell->name_len; |
|
if (size == 0) |
|
return namelen; |
|
if (namelen > size) |
|
return -ERANGE; |
|
memcpy(buffer, cell->name, namelen); |
|
return namelen; |
|
} |
|
|
|
static const struct xattr_handler afs_xattr_afs_cell_handler = { |
|
.name = "afs.cell", |
|
.get = afs_xattr_get_cell, |
|
}; |
|
|
|
/* |
|
* Get the volume ID, vnode ID and vnode uniquifier of a file as a sequence of |
|
* hex numbers separated by colons. |
|
*/ |
|
static int afs_xattr_get_fid(const struct xattr_handler *handler, |
|
struct dentry *dentry, |
|
struct inode *inode, const char *name, |
|
void *buffer, size_t size) |
|
{ |
|
struct afs_vnode *vnode = AFS_FS_I(inode); |
|
char text[16 + 1 + 24 + 1 + 8 + 1]; |
|
size_t len; |
|
|
|
/* The volume ID is 64-bit, the vnode ID is 96-bit and the |
|
* uniquifier is 32-bit. |
|
*/ |
|
len = scnprintf(text, sizeof(text), "%llx:", vnode->fid.vid); |
|
if (vnode->fid.vnode_hi) |
|
len += scnprintf(text + len, sizeof(text) - len, "%x%016llx", |
|
vnode->fid.vnode_hi, vnode->fid.vnode); |
|
else |
|
len += scnprintf(text + len, sizeof(text) - len, "%llx", |
|
vnode->fid.vnode); |
|
len += scnprintf(text + len, sizeof(text) - len, ":%x", |
|
vnode->fid.unique); |
|
|
|
if (size == 0) |
|
return len; |
|
if (len > size) |
|
return -ERANGE; |
|
memcpy(buffer, text, len); |
|
return len; |
|
} |
|
|
|
static const struct xattr_handler afs_xattr_afs_fid_handler = { |
|
.name = "afs.fid", |
|
.get = afs_xattr_get_fid, |
|
}; |
|
|
|
/* |
|
* Get the name of the volume on which a file resides. |
|
*/ |
|
static int afs_xattr_get_volume(const struct xattr_handler *handler, |
|
struct dentry *dentry, |
|
struct inode *inode, const char *name, |
|
void *buffer, size_t size) |
|
{ |
|
struct afs_vnode *vnode = AFS_FS_I(inode); |
|
const char *volname = vnode->volume->name; |
|
size_t namelen; |
|
|
|
namelen = strlen(volname); |
|
if (size == 0) |
|
return namelen; |
|
if (namelen > size) |
|
return -ERANGE; |
|
memcpy(buffer, volname, namelen); |
|
return namelen; |
|
} |
|
|
|
static const struct xattr_handler afs_xattr_afs_volume_handler = { |
|
.name = "afs.volume", |
|
.get = afs_xattr_get_volume, |
|
}; |
|
|
|
const struct xattr_handler *afs_xattr_handlers[] = { |
|
&afs_xattr_afs_acl_handler, |
|
&afs_xattr_afs_cell_handler, |
|
&afs_xattr_afs_fid_handler, |
|
&afs_xattr_afs_volume_handler, |
|
&afs_xattr_yfs_handler, /* afs.yfs. prefix */ |
|
NULL |
|
};
|
|
|