mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-26 05:34:13 +08:00
f57a3fe449
Convert the erofs to use new internal mount API as the old one will be obsoleted and removed. This allows greater flexibility in communication of mount parameters between userspace, the VFS and the filesystem. See Documentation/filesystems/mount_api.txt for more information. Cc: Al Viro <viro@zeniv.linux.org.uk> Cc: David Howells <dhowells@redhat.com> Signed-off-by: Chao Yu <yuchao0@huawei.com> Link: https://lore.kernel.org/r/20200529104836.17843-1-hsiangkao@redhat.com Signed-off-by: Gao Xiang <hsiangkao@redhat.com>
707 lines
17 KiB
C
707 lines
17 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Copyright (C) 2017-2018 HUAWEI, Inc.
|
|
* http://www.huawei.com/
|
|
* Created by Gao Xiang <gaoxiang25@huawei.com>
|
|
*/
|
|
#include <linux/security.h>
|
|
#include "xattr.h"
|
|
|
|
struct xattr_iter {
|
|
struct super_block *sb;
|
|
struct page *page;
|
|
void *kaddr;
|
|
|
|
erofs_blk_t blkaddr;
|
|
unsigned int ofs;
|
|
};
|
|
|
|
static inline void xattr_iter_end(struct xattr_iter *it, bool atomic)
|
|
{
|
|
/* the only user of kunmap() is 'init_inode_xattrs' */
|
|
if (!atomic)
|
|
kunmap(it->page);
|
|
else
|
|
kunmap_atomic(it->kaddr);
|
|
|
|
unlock_page(it->page);
|
|
put_page(it->page);
|
|
}
|
|
|
|
static inline void xattr_iter_end_final(struct xattr_iter *it)
|
|
{
|
|
if (!it->page)
|
|
return;
|
|
|
|
xattr_iter_end(it, true);
|
|
}
|
|
|
|
static int init_inode_xattrs(struct inode *inode)
|
|
{
|
|
struct erofs_inode *const vi = EROFS_I(inode);
|
|
struct xattr_iter it;
|
|
unsigned int i;
|
|
struct erofs_xattr_ibody_header *ih;
|
|
struct super_block *sb;
|
|
struct erofs_sb_info *sbi;
|
|
bool atomic_map;
|
|
int ret = 0;
|
|
|
|
/* the most case is that xattrs of this inode are initialized. */
|
|
if (test_bit(EROFS_I_EA_INITED_BIT, &vi->flags))
|
|
return 0;
|
|
|
|
if (wait_on_bit_lock(&vi->flags, EROFS_I_BL_XATTR_BIT, TASK_KILLABLE))
|
|
return -ERESTARTSYS;
|
|
|
|
/* someone has initialized xattrs for us? */
|
|
if (test_bit(EROFS_I_EA_INITED_BIT, &vi->flags))
|
|
goto out_unlock;
|
|
|
|
/*
|
|
* bypass all xattr operations if ->xattr_isize is not greater than
|
|
* sizeof(struct erofs_xattr_ibody_header), in detail:
|
|
* 1) it is not enough to contain erofs_xattr_ibody_header then
|
|
* ->xattr_isize should be 0 (it means no xattr);
|
|
* 2) it is just to contain erofs_xattr_ibody_header, which is on-disk
|
|
* undefined right now (maybe use later with some new sb feature).
|
|
*/
|
|
if (vi->xattr_isize == sizeof(struct erofs_xattr_ibody_header)) {
|
|
erofs_err(inode->i_sb,
|
|
"xattr_isize %d of nid %llu is not supported yet",
|
|
vi->xattr_isize, vi->nid);
|
|
ret = -EOPNOTSUPP;
|
|
goto out_unlock;
|
|
} else if (vi->xattr_isize < sizeof(struct erofs_xattr_ibody_header)) {
|
|
if (vi->xattr_isize) {
|
|
erofs_err(inode->i_sb,
|
|
"bogus xattr ibody @ nid %llu", vi->nid);
|
|
DBG_BUGON(1);
|
|
ret = -EFSCORRUPTED;
|
|
goto out_unlock; /* xattr ondisk layout error */
|
|
}
|
|
ret = -ENOATTR;
|
|
goto out_unlock;
|
|
}
|
|
|
|
sb = inode->i_sb;
|
|
sbi = EROFS_SB(sb);
|
|
it.blkaddr = erofs_blknr(iloc(sbi, vi->nid) + vi->inode_isize);
|
|
it.ofs = erofs_blkoff(iloc(sbi, vi->nid) + vi->inode_isize);
|
|
|
|
it.page = erofs_get_meta_page(sb, it.blkaddr);
|
|
if (IS_ERR(it.page)) {
|
|
ret = PTR_ERR(it.page);
|
|
goto out_unlock;
|
|
}
|
|
|
|
/* read in shared xattr array (non-atomic, see kmalloc below) */
|
|
it.kaddr = kmap(it.page);
|
|
atomic_map = false;
|
|
|
|
ih = (struct erofs_xattr_ibody_header *)(it.kaddr + it.ofs);
|
|
|
|
vi->xattr_shared_count = ih->h_shared_count;
|
|
vi->xattr_shared_xattrs = kmalloc_array(vi->xattr_shared_count,
|
|
sizeof(uint), GFP_KERNEL);
|
|
if (!vi->xattr_shared_xattrs) {
|
|
xattr_iter_end(&it, atomic_map);
|
|
ret = -ENOMEM;
|
|
goto out_unlock;
|
|
}
|
|
|
|
/* let's skip ibody header */
|
|
it.ofs += sizeof(struct erofs_xattr_ibody_header);
|
|
|
|
for (i = 0; i < vi->xattr_shared_count; ++i) {
|
|
if (it.ofs >= EROFS_BLKSIZ) {
|
|
/* cannot be unaligned */
|
|
DBG_BUGON(it.ofs != EROFS_BLKSIZ);
|
|
xattr_iter_end(&it, atomic_map);
|
|
|
|
it.page = erofs_get_meta_page(sb, ++it.blkaddr);
|
|
if (IS_ERR(it.page)) {
|
|
kfree(vi->xattr_shared_xattrs);
|
|
vi->xattr_shared_xattrs = NULL;
|
|
ret = PTR_ERR(it.page);
|
|
goto out_unlock;
|
|
}
|
|
|
|
it.kaddr = kmap_atomic(it.page);
|
|
atomic_map = true;
|
|
it.ofs = 0;
|
|
}
|
|
vi->xattr_shared_xattrs[i] =
|
|
le32_to_cpu(*(__le32 *)(it.kaddr + it.ofs));
|
|
it.ofs += sizeof(__le32);
|
|
}
|
|
xattr_iter_end(&it, atomic_map);
|
|
|
|
set_bit(EROFS_I_EA_INITED_BIT, &vi->flags);
|
|
|
|
out_unlock:
|
|
clear_and_wake_up_bit(EROFS_I_BL_XATTR_BIT, &vi->flags);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* the general idea for these return values is
|
|
* if 0 is returned, go on processing the current xattr;
|
|
* 1 (> 0) is returned, skip this round to process the next xattr;
|
|
* -err (< 0) is returned, an error (maybe ENOXATTR) occurred
|
|
* and need to be handled
|
|
*/
|
|
struct xattr_iter_handlers {
|
|
int (*entry)(struct xattr_iter *_it, struct erofs_xattr_entry *entry);
|
|
int (*name)(struct xattr_iter *_it, unsigned int processed, char *buf,
|
|
unsigned int len);
|
|
int (*alloc_buffer)(struct xattr_iter *_it, unsigned int value_sz);
|
|
void (*value)(struct xattr_iter *_it, unsigned int processed, char *buf,
|
|
unsigned int len);
|
|
};
|
|
|
|
static inline int xattr_iter_fixup(struct xattr_iter *it)
|
|
{
|
|
if (it->ofs < EROFS_BLKSIZ)
|
|
return 0;
|
|
|
|
xattr_iter_end(it, true);
|
|
|
|
it->blkaddr += erofs_blknr(it->ofs);
|
|
|
|
it->page = erofs_get_meta_page(it->sb, it->blkaddr);
|
|
if (IS_ERR(it->page)) {
|
|
int err = PTR_ERR(it->page);
|
|
|
|
it->page = NULL;
|
|
return err;
|
|
}
|
|
|
|
it->kaddr = kmap_atomic(it->page);
|
|
it->ofs = erofs_blkoff(it->ofs);
|
|
return 0;
|
|
}
|
|
|
|
static int inline_xattr_iter_begin(struct xattr_iter *it,
|
|
struct inode *inode)
|
|
{
|
|
struct erofs_inode *const vi = EROFS_I(inode);
|
|
struct erofs_sb_info *const sbi = EROFS_SB(inode->i_sb);
|
|
unsigned int xattr_header_sz, inline_xattr_ofs;
|
|
|
|
xattr_header_sz = inlinexattr_header_size(inode);
|
|
if (xattr_header_sz >= vi->xattr_isize) {
|
|
DBG_BUGON(xattr_header_sz > vi->xattr_isize);
|
|
return -ENOATTR;
|
|
}
|
|
|
|
inline_xattr_ofs = vi->inode_isize + xattr_header_sz;
|
|
|
|
it->blkaddr = erofs_blknr(iloc(sbi, vi->nid) + inline_xattr_ofs);
|
|
it->ofs = erofs_blkoff(iloc(sbi, vi->nid) + inline_xattr_ofs);
|
|
|
|
it->page = erofs_get_meta_page(inode->i_sb, it->blkaddr);
|
|
if (IS_ERR(it->page))
|
|
return PTR_ERR(it->page);
|
|
|
|
it->kaddr = kmap_atomic(it->page);
|
|
return vi->xattr_isize - xattr_header_sz;
|
|
}
|
|
|
|
/*
|
|
* Regardless of success or failure, `xattr_foreach' will end up with
|
|
* `ofs' pointing to the next xattr item rather than an arbitrary position.
|
|
*/
|
|
static int xattr_foreach(struct xattr_iter *it,
|
|
const struct xattr_iter_handlers *op,
|
|
unsigned int *tlimit)
|
|
{
|
|
struct erofs_xattr_entry entry;
|
|
unsigned int value_sz, processed, slice;
|
|
int err;
|
|
|
|
/* 0. fixup blkaddr, ofs, ipage */
|
|
err = xattr_iter_fixup(it);
|
|
if (err)
|
|
return err;
|
|
|
|
/*
|
|
* 1. read xattr entry to the memory,
|
|
* since we do EROFS_XATTR_ALIGN
|
|
* therefore entry should be in the page
|
|
*/
|
|
entry = *(struct erofs_xattr_entry *)(it->kaddr + it->ofs);
|
|
if (tlimit) {
|
|
unsigned int entry_sz = erofs_xattr_entry_size(&entry);
|
|
|
|
/* xattr on-disk corruption: xattr entry beyond xattr_isize */
|
|
if (*tlimit < entry_sz) {
|
|
DBG_BUGON(1);
|
|
return -EFSCORRUPTED;
|
|
}
|
|
*tlimit -= entry_sz;
|
|
}
|
|
|
|
it->ofs += sizeof(struct erofs_xattr_entry);
|
|
value_sz = le16_to_cpu(entry.e_value_size);
|
|
|
|
/* handle entry */
|
|
err = op->entry(it, &entry);
|
|
if (err) {
|
|
it->ofs += entry.e_name_len + value_sz;
|
|
goto out;
|
|
}
|
|
|
|
/* 2. handle xattr name (ofs will finally be at the end of name) */
|
|
processed = 0;
|
|
|
|
while (processed < entry.e_name_len) {
|
|
if (it->ofs >= EROFS_BLKSIZ) {
|
|
DBG_BUGON(it->ofs > EROFS_BLKSIZ);
|
|
|
|
err = xattr_iter_fixup(it);
|
|
if (err)
|
|
goto out;
|
|
it->ofs = 0;
|
|
}
|
|
|
|
slice = min_t(unsigned int, PAGE_SIZE - it->ofs,
|
|
entry.e_name_len - processed);
|
|
|
|
/* handle name */
|
|
err = op->name(it, processed, it->kaddr + it->ofs, slice);
|
|
if (err) {
|
|
it->ofs += entry.e_name_len - processed + value_sz;
|
|
goto out;
|
|
}
|
|
|
|
it->ofs += slice;
|
|
processed += slice;
|
|
}
|
|
|
|
/* 3. handle xattr value */
|
|
processed = 0;
|
|
|
|
if (op->alloc_buffer) {
|
|
err = op->alloc_buffer(it, value_sz);
|
|
if (err) {
|
|
it->ofs += value_sz;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
while (processed < value_sz) {
|
|
if (it->ofs >= EROFS_BLKSIZ) {
|
|
DBG_BUGON(it->ofs > EROFS_BLKSIZ);
|
|
|
|
err = xattr_iter_fixup(it);
|
|
if (err)
|
|
goto out;
|
|
it->ofs = 0;
|
|
}
|
|
|
|
slice = min_t(unsigned int, PAGE_SIZE - it->ofs,
|
|
value_sz - processed);
|
|
op->value(it, processed, it->kaddr + it->ofs, slice);
|
|
it->ofs += slice;
|
|
processed += slice;
|
|
}
|
|
|
|
out:
|
|
/* xattrs should be 4-byte aligned (on-disk constraint) */
|
|
it->ofs = EROFS_XATTR_ALIGN(it->ofs);
|
|
return err < 0 ? err : 0;
|
|
}
|
|
|
|
struct getxattr_iter {
|
|
struct xattr_iter it;
|
|
|
|
char *buffer;
|
|
int buffer_size, index;
|
|
struct qstr name;
|
|
};
|
|
|
|
static int xattr_entrymatch(struct xattr_iter *_it,
|
|
struct erofs_xattr_entry *entry)
|
|
{
|
|
struct getxattr_iter *it = container_of(_it, struct getxattr_iter, it);
|
|
|
|
return (it->index != entry->e_name_index ||
|
|
it->name.len != entry->e_name_len) ? -ENOATTR : 0;
|
|
}
|
|
|
|
static int xattr_namematch(struct xattr_iter *_it,
|
|
unsigned int processed, char *buf, unsigned int len)
|
|
{
|
|
struct getxattr_iter *it = container_of(_it, struct getxattr_iter, it);
|
|
|
|
return memcmp(buf, it->name.name + processed, len) ? -ENOATTR : 0;
|
|
}
|
|
|
|
static int xattr_checkbuffer(struct xattr_iter *_it,
|
|
unsigned int value_sz)
|
|
{
|
|
struct getxattr_iter *it = container_of(_it, struct getxattr_iter, it);
|
|
int err = it->buffer_size < value_sz ? -ERANGE : 0;
|
|
|
|
it->buffer_size = value_sz;
|
|
return !it->buffer ? 1 : err;
|
|
}
|
|
|
|
static void xattr_copyvalue(struct xattr_iter *_it,
|
|
unsigned int processed,
|
|
char *buf, unsigned int len)
|
|
{
|
|
struct getxattr_iter *it = container_of(_it, struct getxattr_iter, it);
|
|
|
|
memcpy(it->buffer + processed, buf, len);
|
|
}
|
|
|
|
static const struct xattr_iter_handlers find_xattr_handlers = {
|
|
.entry = xattr_entrymatch,
|
|
.name = xattr_namematch,
|
|
.alloc_buffer = xattr_checkbuffer,
|
|
.value = xattr_copyvalue
|
|
};
|
|
|
|
static int inline_getxattr(struct inode *inode, struct getxattr_iter *it)
|
|
{
|
|
int ret;
|
|
unsigned int remaining;
|
|
|
|
ret = inline_xattr_iter_begin(&it->it, inode);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
remaining = ret;
|
|
while (remaining) {
|
|
ret = xattr_foreach(&it->it, &find_xattr_handlers, &remaining);
|
|
if (ret != -ENOATTR)
|
|
break;
|
|
}
|
|
xattr_iter_end_final(&it->it);
|
|
|
|
return ret ? ret : it->buffer_size;
|
|
}
|
|
|
|
static int shared_getxattr(struct inode *inode, struct getxattr_iter *it)
|
|
{
|
|
struct erofs_inode *const vi = EROFS_I(inode);
|
|
struct super_block *const sb = inode->i_sb;
|
|
struct erofs_sb_info *const sbi = EROFS_SB(sb);
|
|
unsigned int i;
|
|
int ret = -ENOATTR;
|
|
|
|
for (i = 0; i < vi->xattr_shared_count; ++i) {
|
|
erofs_blk_t blkaddr =
|
|
xattrblock_addr(sbi, vi->xattr_shared_xattrs[i]);
|
|
|
|
it->it.ofs = xattrblock_offset(sbi, vi->xattr_shared_xattrs[i]);
|
|
|
|
if (!i || blkaddr != it->it.blkaddr) {
|
|
if (i)
|
|
xattr_iter_end(&it->it, true);
|
|
|
|
it->it.page = erofs_get_meta_page(sb, blkaddr);
|
|
if (IS_ERR(it->it.page))
|
|
return PTR_ERR(it->it.page);
|
|
|
|
it->it.kaddr = kmap_atomic(it->it.page);
|
|
it->it.blkaddr = blkaddr;
|
|
}
|
|
|
|
ret = xattr_foreach(&it->it, &find_xattr_handlers, NULL);
|
|
if (ret != -ENOATTR)
|
|
break;
|
|
}
|
|
if (vi->xattr_shared_count)
|
|
xattr_iter_end_final(&it->it);
|
|
|
|
return ret ? ret : it->buffer_size;
|
|
}
|
|
|
|
static bool erofs_xattr_user_list(struct dentry *dentry)
|
|
{
|
|
return test_opt(&EROFS_SB(dentry->d_sb)->ctx, XATTR_USER);
|
|
}
|
|
|
|
static bool erofs_xattr_trusted_list(struct dentry *dentry)
|
|
{
|
|
return capable(CAP_SYS_ADMIN);
|
|
}
|
|
|
|
int erofs_getxattr(struct inode *inode, int index,
|
|
const char *name,
|
|
void *buffer, size_t buffer_size)
|
|
{
|
|
int ret;
|
|
struct getxattr_iter it;
|
|
|
|
if (!name)
|
|
return -EINVAL;
|
|
|
|
ret = init_inode_xattrs(inode);
|
|
if (ret)
|
|
return ret;
|
|
|
|
it.index = index;
|
|
|
|
it.name.len = strlen(name);
|
|
if (it.name.len > EROFS_NAME_LEN)
|
|
return -ERANGE;
|
|
it.name.name = name;
|
|
|
|
it.buffer = buffer;
|
|
it.buffer_size = buffer_size;
|
|
|
|
it.it.sb = inode->i_sb;
|
|
ret = inline_getxattr(inode, &it);
|
|
if (ret == -ENOATTR)
|
|
ret = shared_getxattr(inode, &it);
|
|
return ret;
|
|
}
|
|
|
|
static int erofs_xattr_generic_get(const struct xattr_handler *handler,
|
|
struct dentry *unused, struct inode *inode,
|
|
const char *name, void *buffer, size_t size)
|
|
{
|
|
struct erofs_sb_info *const sbi = EROFS_I_SB(inode);
|
|
|
|
switch (handler->flags) {
|
|
case EROFS_XATTR_INDEX_USER:
|
|
if (!test_opt(&sbi->ctx, XATTR_USER))
|
|
return -EOPNOTSUPP;
|
|
break;
|
|
case EROFS_XATTR_INDEX_TRUSTED:
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EPERM;
|
|
break;
|
|
case EROFS_XATTR_INDEX_SECURITY:
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return erofs_getxattr(inode, handler->flags, name, buffer, size);
|
|
}
|
|
|
|
const struct xattr_handler erofs_xattr_user_handler = {
|
|
.prefix = XATTR_USER_PREFIX,
|
|
.flags = EROFS_XATTR_INDEX_USER,
|
|
.list = erofs_xattr_user_list,
|
|
.get = erofs_xattr_generic_get,
|
|
};
|
|
|
|
const struct xattr_handler erofs_xattr_trusted_handler = {
|
|
.prefix = XATTR_TRUSTED_PREFIX,
|
|
.flags = EROFS_XATTR_INDEX_TRUSTED,
|
|
.list = erofs_xattr_trusted_list,
|
|
.get = erofs_xattr_generic_get,
|
|
};
|
|
|
|
#ifdef CONFIG_EROFS_FS_SECURITY
|
|
const struct xattr_handler __maybe_unused erofs_xattr_security_handler = {
|
|
.prefix = XATTR_SECURITY_PREFIX,
|
|
.flags = EROFS_XATTR_INDEX_SECURITY,
|
|
.get = erofs_xattr_generic_get,
|
|
};
|
|
#endif
|
|
|
|
const struct xattr_handler *erofs_xattr_handlers[] = {
|
|
&erofs_xattr_user_handler,
|
|
#ifdef CONFIG_EROFS_FS_POSIX_ACL
|
|
&posix_acl_access_xattr_handler,
|
|
&posix_acl_default_xattr_handler,
|
|
#endif
|
|
&erofs_xattr_trusted_handler,
|
|
#ifdef CONFIG_EROFS_FS_SECURITY
|
|
&erofs_xattr_security_handler,
|
|
#endif
|
|
NULL,
|
|
};
|
|
|
|
struct listxattr_iter {
|
|
struct xattr_iter it;
|
|
|
|
struct dentry *dentry;
|
|
char *buffer;
|
|
int buffer_size, buffer_ofs;
|
|
};
|
|
|
|
static int xattr_entrylist(struct xattr_iter *_it,
|
|
struct erofs_xattr_entry *entry)
|
|
{
|
|
struct listxattr_iter *it =
|
|
container_of(_it, struct listxattr_iter, it);
|
|
unsigned int prefix_len;
|
|
const char *prefix;
|
|
|
|
const struct xattr_handler *h =
|
|
erofs_xattr_handler(entry->e_name_index);
|
|
|
|
if (!h || (h->list && !h->list(it->dentry)))
|
|
return 1;
|
|
|
|
prefix = xattr_prefix(h);
|
|
prefix_len = strlen(prefix);
|
|
|
|
if (!it->buffer) {
|
|
it->buffer_ofs += prefix_len + entry->e_name_len + 1;
|
|
return 1;
|
|
}
|
|
|
|
if (it->buffer_ofs + prefix_len
|
|
+ entry->e_name_len + 1 > it->buffer_size)
|
|
return -ERANGE;
|
|
|
|
memcpy(it->buffer + it->buffer_ofs, prefix, prefix_len);
|
|
it->buffer_ofs += prefix_len;
|
|
return 0;
|
|
}
|
|
|
|
static int xattr_namelist(struct xattr_iter *_it,
|
|
unsigned int processed, char *buf, unsigned int len)
|
|
{
|
|
struct listxattr_iter *it =
|
|
container_of(_it, struct listxattr_iter, it);
|
|
|
|
memcpy(it->buffer + it->buffer_ofs, buf, len);
|
|
it->buffer_ofs += len;
|
|
return 0;
|
|
}
|
|
|
|
static int xattr_skipvalue(struct xattr_iter *_it,
|
|
unsigned int value_sz)
|
|
{
|
|
struct listxattr_iter *it =
|
|
container_of(_it, struct listxattr_iter, it);
|
|
|
|
it->buffer[it->buffer_ofs++] = '\0';
|
|
return 1;
|
|
}
|
|
|
|
static const struct xattr_iter_handlers list_xattr_handlers = {
|
|
.entry = xattr_entrylist,
|
|
.name = xattr_namelist,
|
|
.alloc_buffer = xattr_skipvalue,
|
|
.value = NULL
|
|
};
|
|
|
|
static int inline_listxattr(struct listxattr_iter *it)
|
|
{
|
|
int ret;
|
|
unsigned int remaining;
|
|
|
|
ret = inline_xattr_iter_begin(&it->it, d_inode(it->dentry));
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
remaining = ret;
|
|
while (remaining) {
|
|
ret = xattr_foreach(&it->it, &list_xattr_handlers, &remaining);
|
|
if (ret)
|
|
break;
|
|
}
|
|
xattr_iter_end_final(&it->it);
|
|
return ret ? ret : it->buffer_ofs;
|
|
}
|
|
|
|
static int shared_listxattr(struct listxattr_iter *it)
|
|
{
|
|
struct inode *const inode = d_inode(it->dentry);
|
|
struct erofs_inode *const vi = EROFS_I(inode);
|
|
struct super_block *const sb = inode->i_sb;
|
|
struct erofs_sb_info *const sbi = EROFS_SB(sb);
|
|
unsigned int i;
|
|
int ret = 0;
|
|
|
|
for (i = 0; i < vi->xattr_shared_count; ++i) {
|
|
erofs_blk_t blkaddr =
|
|
xattrblock_addr(sbi, vi->xattr_shared_xattrs[i]);
|
|
|
|
it->it.ofs = xattrblock_offset(sbi, vi->xattr_shared_xattrs[i]);
|
|
if (!i || blkaddr != it->it.blkaddr) {
|
|
if (i)
|
|
xattr_iter_end(&it->it, true);
|
|
|
|
it->it.page = erofs_get_meta_page(sb, blkaddr);
|
|
if (IS_ERR(it->it.page))
|
|
return PTR_ERR(it->it.page);
|
|
|
|
it->it.kaddr = kmap_atomic(it->it.page);
|
|
it->it.blkaddr = blkaddr;
|
|
}
|
|
|
|
ret = xattr_foreach(&it->it, &list_xattr_handlers, NULL);
|
|
if (ret)
|
|
break;
|
|
}
|
|
if (vi->xattr_shared_count)
|
|
xattr_iter_end_final(&it->it);
|
|
|
|
return ret ? ret : it->buffer_ofs;
|
|
}
|
|
|
|
ssize_t erofs_listxattr(struct dentry *dentry,
|
|
char *buffer, size_t buffer_size)
|
|
{
|
|
int ret;
|
|
struct listxattr_iter it;
|
|
|
|
ret = init_inode_xattrs(d_inode(dentry));
|
|
if (ret == -ENOATTR)
|
|
return 0;
|
|
if (ret)
|
|
return ret;
|
|
|
|
it.dentry = dentry;
|
|
it.buffer = buffer;
|
|
it.buffer_size = buffer_size;
|
|
it.buffer_ofs = 0;
|
|
|
|
it.it.sb = dentry->d_sb;
|
|
|
|
ret = inline_listxattr(&it);
|
|
if (ret < 0 && ret != -ENOATTR)
|
|
return ret;
|
|
return shared_listxattr(&it);
|
|
}
|
|
|
|
#ifdef CONFIG_EROFS_FS_POSIX_ACL
|
|
struct posix_acl *erofs_get_acl(struct inode *inode, int type)
|
|
{
|
|
struct posix_acl *acl;
|
|
int prefix, rc;
|
|
char *value = NULL;
|
|
|
|
switch (type) {
|
|
case ACL_TYPE_ACCESS:
|
|
prefix = EROFS_XATTR_INDEX_POSIX_ACL_ACCESS;
|
|
break;
|
|
case ACL_TYPE_DEFAULT:
|
|
prefix = EROFS_XATTR_INDEX_POSIX_ACL_DEFAULT;
|
|
break;
|
|
default:
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
rc = erofs_getxattr(inode, prefix, "", NULL, 0);
|
|
if (rc > 0) {
|
|
value = kmalloc(rc, GFP_KERNEL);
|
|
if (!value)
|
|
return ERR_PTR(-ENOMEM);
|
|
rc = erofs_getxattr(inode, prefix, "", value, rc);
|
|
}
|
|
|
|
if (rc == -ENOATTR)
|
|
acl = NULL;
|
|
else if (rc < 0)
|
|
acl = ERR_PTR(rc);
|
|
else
|
|
acl = posix_acl_from_xattr(&init_user_ns, value, rc);
|
|
kfree(value);
|
|
return acl;
|
|
}
|
|
#endif
|
|
|