2006-10-11 15:20:50 +07:00
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* linux/fs/ext4/xattr.c
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
|
|
|
|
*
|
|
|
|
* Fix by Harrison Xing <harrison@mountainviewdata.com>.
|
2006-10-11 15:20:53 +07:00
|
|
|
* Ext4 code with a lot of help from Eric Jarman <ejarman@acm.org>.
|
2006-10-11 15:20:50 +07:00
|
|
|
* Extended attributes for symlinks and special files added per
|
|
|
|
* suggestion of Luka Renko <luka.renko@hermes.si>.
|
|
|
|
* xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
|
|
|
|
* Red Hat Inc.
|
|
|
|
* ea-in-inode support by Alex Tomas <alex@clusterfs.com> aka bzzz
|
|
|
|
* and Andreas Gruenbacher <agruen@suse.de>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extended attributes are stored directly in inodes (on file systems with
|
|
|
|
* inodes bigger than 128 bytes) and on additional disk blocks. The i_file_acl
|
|
|
|
* field contains the block number if an inode uses an additional block. All
|
|
|
|
* attributes must fit in the inode and one additional block. Blocks that
|
|
|
|
* contain the identical set of attributes may be shared among several inodes.
|
|
|
|
* Identical blocks are detected by keeping a cache of blocks that have
|
|
|
|
* recently been accessed.
|
|
|
|
*
|
|
|
|
* The attributes in inodes and on blocks have a different header; the entries
|
|
|
|
* are stored in the same format:
|
|
|
|
*
|
|
|
|
* +------------------+
|
|
|
|
* | header |
|
|
|
|
* | entry 1 | |
|
|
|
|
* | entry 2 | | growing downwards
|
|
|
|
* | entry 3 | v
|
|
|
|
* | four null bytes |
|
|
|
|
* | . . . |
|
|
|
|
* | value 1 | ^
|
|
|
|
* | value 3 | | growing upwards
|
|
|
|
* | value 2 | |
|
|
|
|
* +------------------+
|
|
|
|
*
|
|
|
|
* The header is followed by multiple entry descriptors. In disk blocks, the
|
|
|
|
* entry descriptors are kept sorted. In inodes, they are unsorted. The
|
|
|
|
* attribute values are aligned to the end of the block in no specific order.
|
|
|
|
*
|
|
|
|
* Locking strategy
|
|
|
|
* ----------------
|
2006-10-11 15:20:53 +07:00
|
|
|
* EXT4_I(inode)->i_file_acl is protected by EXT4_I(inode)->xattr_sem.
|
2006-10-11 15:20:50 +07:00
|
|
|
* EA blocks are only changed if they are exclusive to an inode, so
|
|
|
|
* holding xattr_sem also means that nothing but the EA block's reference
|
|
|
|
* count can change. Multiple writers to the same block are synchronized
|
|
|
|
* by the buffer lock.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/slab.h>
|
2016-02-23 10:35:22 +07:00
|
|
|
#include <linux/mbcache.h>
|
2006-10-11 15:20:50 +07:00
|
|
|
#include <linux/quotaops.h>
|
2008-04-30 05:13:32 +07:00
|
|
|
#include "ext4_jbd2.h"
|
|
|
|
#include "ext4.h"
|
2006-10-11 15:20:50 +07:00
|
|
|
#include "xattr.h"
|
|
|
|
#include "acl.h"
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
#ifdef EXT4_XATTR_DEBUG
|
2006-10-11 15:20:50 +07:00
|
|
|
# define ea_idebug(inode, f...) do { \
|
|
|
|
printk(KERN_DEBUG "inode %s:%lu: ", \
|
|
|
|
inode->i_sb->s_id, inode->i_ino); \
|
|
|
|
printk(f); \
|
|
|
|
printk("\n"); \
|
|
|
|
} while (0)
|
|
|
|
# define ea_bdebug(bh, f...) do { \
|
2015-04-13 19:31:37 +07:00
|
|
|
printk(KERN_DEBUG "block %pg:%lu: ", \
|
|
|
|
bh->b_bdev, (unsigned long) bh->b_blocknr); \
|
2006-10-11 15:20:50 +07:00
|
|
|
printk(f); \
|
|
|
|
printk("\n"); \
|
|
|
|
} while (0)
|
|
|
|
#else
|
2012-03-20 10:11:43 +07:00
|
|
|
# define ea_idebug(inode, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
|
|
|
|
# define ea_bdebug(bh, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
|
2006-10-11 15:20:50 +07:00
|
|
|
#endif
|
|
|
|
|
2016-02-23 10:35:22 +07:00
|
|
|
static void ext4_xattr_cache_insert(struct mb_cache *, struct buffer_head *);
|
2006-10-11 15:20:53 +07:00
|
|
|
static struct buffer_head *ext4_xattr_cache_find(struct inode *,
|
|
|
|
struct ext4_xattr_header *,
|
2016-02-23 10:35:22 +07:00
|
|
|
struct mb_cache_entry **);
|
2006-10-11 15:20:53 +07:00
|
|
|
static void ext4_xattr_rehash(struct ext4_xattr_header *,
|
|
|
|
struct ext4_xattr_entry *);
|
2009-11-13 16:52:56 +07:00
|
|
|
static int ext4_xattr_list(struct dentry *dentry, char *buffer,
|
2008-04-17 21:38:59 +07:00
|
|
|
size_t buffer_size);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2010-05-14 07:53:18 +07:00
|
|
|
static const struct xattr_handler *ext4_xattr_handler_map[] = {
|
2006-10-11 15:20:53 +07:00
|
|
|
[EXT4_XATTR_INDEX_USER] = &ext4_xattr_user_handler,
|
2008-10-11 07:02:48 +07:00
|
|
|
#ifdef CONFIG_EXT4_FS_POSIX_ACL
|
2013-12-20 20:16:44 +07:00
|
|
|
[EXT4_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
|
|
|
|
[EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
|
2006-10-11 15:20:50 +07:00
|
|
|
#endif
|
2006-10-11 15:20:53 +07:00
|
|
|
[EXT4_XATTR_INDEX_TRUSTED] = &ext4_xattr_trusted_handler,
|
2008-10-11 07:02:48 +07:00
|
|
|
#ifdef CONFIG_EXT4_FS_SECURITY
|
2006-10-11 15:20:53 +07:00
|
|
|
[EXT4_XATTR_INDEX_SECURITY] = &ext4_xattr_security_handler,
|
2006-10-11 15:20:50 +07:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2010-05-14 07:53:18 +07:00
|
|
|
const struct xattr_handler *ext4_xattr_handlers[] = {
|
2006-10-11 15:20:53 +07:00
|
|
|
&ext4_xattr_user_handler,
|
|
|
|
&ext4_xattr_trusted_handler,
|
2008-10-11 07:02:48 +07:00
|
|
|
#ifdef CONFIG_EXT4_FS_POSIX_ACL
|
2013-12-20 20:16:44 +07:00
|
|
|
&posix_acl_access_xattr_handler,
|
|
|
|
&posix_acl_default_xattr_handler,
|
2006-10-11 15:20:50 +07:00
|
|
|
#endif
|
2008-10-11 07:02:48 +07:00
|
|
|
#ifdef CONFIG_EXT4_FS_SECURITY
|
2006-10-11 15:20:53 +07:00
|
|
|
&ext4_xattr_security_handler,
|
2006-10-11 15:20:50 +07:00
|
|
|
#endif
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2014-03-19 06:24:49 +07:00
|
|
|
#define EXT4_GET_MB_CACHE(inode) (((struct ext4_sb_info *) \
|
|
|
|
inode->i_sb->s_fs_info)->s_mb_cache)
|
|
|
|
|
2012-04-30 05:43:10 +07:00
|
|
|
static __le32 ext4_xattr_block_csum(struct inode *inode,
|
|
|
|
sector_t block_nr,
|
|
|
|
struct ext4_xattr_header *hdr)
|
|
|
|
{
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
2013-04-10 10:59:55 +07:00
|
|
|
__u32 csum;
|
|
|
|
__le32 save_csum;
|
|
|
|
__le64 dsk_block_nr = cpu_to_le64(block_nr);
|
2012-04-30 05:43:10 +07:00
|
|
|
|
2013-04-10 10:59:55 +07:00
|
|
|
save_csum = hdr->h_checksum;
|
2012-04-30 05:43:10 +07:00
|
|
|
hdr->h_checksum = 0;
|
2013-04-10 10:59:55 +07:00
|
|
|
csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&dsk_block_nr,
|
|
|
|
sizeof(dsk_block_nr));
|
2012-04-30 05:43:10 +07:00
|
|
|
csum = ext4_chksum(sbi, csum, (__u8 *)hdr,
|
|
|
|
EXT4_BLOCK_SIZE(inode->i_sb));
|
2012-07-10 03:29:27 +07:00
|
|
|
|
2013-04-10 10:59:55 +07:00
|
|
|
hdr->h_checksum = save_csum;
|
2012-04-30 05:43:10 +07:00
|
|
|
return cpu_to_le32(csum);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_xattr_block_csum_verify(struct inode *inode,
|
|
|
|
sector_t block_nr,
|
|
|
|
struct ext4_xattr_header *hdr)
|
|
|
|
{
|
2014-10-13 14:36:16 +07:00
|
|
|
if (ext4_has_metadata_csum(inode->i_sb) &&
|
2012-04-30 05:43:10 +07:00
|
|
|
(hdr->h_checksum != ext4_xattr_block_csum(inode, block_nr, hdr)))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ext4_xattr_block_csum_set(struct inode *inode,
|
|
|
|
sector_t block_nr,
|
|
|
|
struct ext4_xattr_header *hdr)
|
|
|
|
{
|
2014-10-13 14:36:16 +07:00
|
|
|
if (!ext4_has_metadata_csum(inode->i_sb))
|
2012-04-30 05:43:10 +07:00
|
|
|
return;
|
|
|
|
|
|
|
|
hdr->h_checksum = ext4_xattr_block_csum(inode, block_nr, hdr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ext4_handle_dirty_xattr_block(handle_t *handle,
|
|
|
|
struct inode *inode,
|
|
|
|
struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
ext4_xattr_block_csum_set(inode, bh->b_blocknr, BHDR(bh));
|
|
|
|
return ext4_handle_dirty_metadata(handle, inode, bh);
|
|
|
|
}
|
|
|
|
|
2010-05-14 07:53:18 +07:00
|
|
|
static inline const struct xattr_handler *
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_handler(int name_index)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2010-05-14 07:53:18 +07:00
|
|
|
const struct xattr_handler *handler = NULL;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
if (name_index > 0 && name_index < ARRAY_SIZE(ext4_xattr_handler_map))
|
|
|
|
handler = ext4_xattr_handler_map[name_index];
|
2006-10-11 15:20:50 +07:00
|
|
|
return handler;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Inode operation listxattr()
|
|
|
|
*
|
2015-03-18 05:25:59 +07:00
|
|
|
* d_inode(dentry)->i_mutex: don't care
|
2006-10-11 15:20:50 +07:00
|
|
|
*/
|
|
|
|
ssize_t
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_listxattr(struct dentry *dentry, char *buffer, size_t size)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2009-11-13 16:52:56 +07:00
|
|
|
return ext4_xattr_list(dentry, buffer, size);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2014-09-17 01:34:59 +07:00
|
|
|
ext4_xattr_check_names(struct ext4_xattr_entry *entry, void *end,
|
|
|
|
void *value_start)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2014-09-17 01:34:59 +07:00
|
|
|
struct ext4_xattr_entry *e = entry;
|
|
|
|
|
|
|
|
while (!IS_LAST_ENTRY(e)) {
|
|
|
|
struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e);
|
2006-10-11 15:20:50 +07:00
|
|
|
if ((void *)next >= end)
|
2015-10-18 03:16:04 +07:00
|
|
|
return -EFSCORRUPTED;
|
2014-09-17 01:34:59 +07:00
|
|
|
e = next;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2014-09-17 01:34:59 +07:00
|
|
|
|
|
|
|
while (!IS_LAST_ENTRY(entry)) {
|
|
|
|
if (entry->e_value_size != 0 &&
|
|
|
|
(value_start + le16_to_cpu(entry->e_value_offs) <
|
|
|
|
(void *)e + sizeof(__u32) ||
|
|
|
|
value_start + le16_to_cpu(entry->e_value_offs) +
|
|
|
|
le32_to_cpu(entry->e_value_size) > end))
|
2015-10-18 03:16:04 +07:00
|
|
|
return -EFSCORRUPTED;
|
2014-09-17 01:34:59 +07:00
|
|
|
entry = EXT4_XATTR_NEXT(entry);
|
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
2012-04-30 05:43:10 +07:00
|
|
|
ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2012-04-30 05:43:10 +07:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (buffer_verified(bh))
|
|
|
|
return 0;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
|
2006-10-11 15:20:50 +07:00
|
|
|
BHDR(bh)->h_blocks != cpu_to_le32(1))
|
2015-10-18 03:16:04 +07:00
|
|
|
return -EFSCORRUPTED;
|
2012-04-30 05:43:10 +07:00
|
|
|
if (!ext4_xattr_block_csum_verify(inode, bh->b_blocknr, BHDR(bh)))
|
2015-10-18 03:16:04 +07:00
|
|
|
return -EFSBADCRC;
|
2014-09-17 01:34:59 +07:00
|
|
|
error = ext4_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size,
|
|
|
|
bh->b_data);
|
2012-04-30 05:43:10 +07:00
|
|
|
if (!error)
|
|
|
|
set_buffer_verified(bh);
|
|
|
|
return error;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_check_entry(struct ext4_xattr_entry *entry, size_t size)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
size_t value_size = le32_to_cpu(entry->e_value_size);
|
|
|
|
|
|
|
|
if (entry->e_value_block != 0 || value_size > size ||
|
|
|
|
le16_to_cpu(entry->e_value_offs) + value_size > size)
|
2015-10-18 03:16:04 +07:00
|
|
|
return -EFSCORRUPTED;
|
2006-10-11 15:20:50 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_find_entry(struct ext4_xattr_entry **pentry, int name_index,
|
2006-10-11 15:20:50 +07:00
|
|
|
const char *name, size_t size, int sorted)
|
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_entry *entry;
|
2006-10-11 15:20:50 +07:00
|
|
|
size_t name_len;
|
|
|
|
int cmp = 1;
|
|
|
|
|
|
|
|
if (name == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
name_len = strlen(name);
|
|
|
|
entry = *pentry;
|
2006-10-11 15:20:53 +07:00
|
|
|
for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
|
2006-10-11 15:20:50 +07:00
|
|
|
cmp = name_index - entry->e_name_index;
|
|
|
|
if (!cmp)
|
|
|
|
cmp = name_len - entry->e_name_len;
|
|
|
|
if (!cmp)
|
|
|
|
cmp = memcmp(name, entry->e_name, name_len);
|
|
|
|
if (cmp <= 0 && (sorted || cmp == 0))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
*pentry = entry;
|
2006-10-11 15:20:53 +07:00
|
|
|
if (!cmp && ext4_xattr_check_entry(entry, size))
|
2015-10-18 03:16:04 +07:00
|
|
|
return -EFSCORRUPTED;
|
2006-10-11 15:20:50 +07:00
|
|
|
return cmp ? -ENODATA : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
|
2006-10-11 15:20:50 +07:00
|
|
|
void *buffer, size_t buffer_size)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_entry *entry;
|
2006-10-11 15:20:50 +07:00
|
|
|
size_t size;
|
|
|
|
int error;
|
2016-02-23 10:35:22 +07:00
|
|
|
struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
|
|
|
|
name_index, name, buffer, (long)buffer_size);
|
|
|
|
|
|
|
|
error = -ENODATA;
|
2006-10-11 15:20:53 +07:00
|
|
|
if (!EXT4_I(inode)->i_file_acl)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
2012-03-20 10:11:43 +07:00
|
|
|
ea_idebug(inode, "reading block %llu",
|
|
|
|
(unsigned long long)EXT4_I(inode)->i_file_acl);
|
2006-10-11 15:20:53 +07:00
|
|
|
bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!bh)
|
|
|
|
goto cleanup;
|
|
|
|
ea_bdebug(bh, "b_count=%d, refcount=%d",
|
|
|
|
atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
|
2012-04-30 05:43:10 +07:00
|
|
|
if (ext4_xattr_check_block(inode, bh)) {
|
2010-02-16 02:19:27 +07:00
|
|
|
bad_block:
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(inode, "bad block %llu",
|
|
|
|
EXT4_I(inode)->i_file_acl);
|
2015-10-18 03:16:04 +07:00
|
|
|
error = -EFSCORRUPTED;
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2014-03-19 06:24:49 +07:00
|
|
|
ext4_xattr_cache_insert(ext4_mb_cache, bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
entry = BFIRST(bh);
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
|
2015-10-18 03:16:04 +07:00
|
|
|
if (error == -EFSCORRUPTED)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto bad_block;
|
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
size = le32_to_cpu(entry->e_value_size);
|
|
|
|
if (buffer) {
|
|
|
|
error = -ERANGE;
|
|
|
|
if (size > buffer_size)
|
|
|
|
goto cleanup;
|
|
|
|
memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
|
|
|
|
size);
|
|
|
|
}
|
|
|
|
error = size;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
brelse(bh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2012-12-05 22:28:46 +07:00
|
|
|
int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
|
2006-10-11 15:20:50 +07:00
|
|
|
void *buffer, size_t buffer_size)
|
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_ibody_header *header;
|
|
|
|
struct ext4_xattr_entry *entry;
|
|
|
|
struct ext4_inode *raw_inode;
|
|
|
|
struct ext4_iloc iloc;
|
2006-10-11 15:20:50 +07:00
|
|
|
size_t size;
|
|
|
|
void *end;
|
|
|
|
int error;
|
|
|
|
|
2010-01-25 02:34:07 +07:00
|
|
|
if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
|
2006-10-11 15:20:50 +07:00
|
|
|
return -ENODATA;
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_get_inode_loc(inode, &iloc);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
return error;
|
2006-10-11 15:20:53 +07:00
|
|
|
raw_inode = ext4_raw_inode(&iloc);
|
2006-10-11 15:20:50 +07:00
|
|
|
header = IHDR(inode, raw_inode);
|
|
|
|
entry = IFIRST(header);
|
2006-10-11 15:20:53 +07:00
|
|
|
end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
|
2014-09-17 01:34:59 +07:00
|
|
|
error = ext4_xattr_check_names(entry, end, entry);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_find_entry(&entry, name_index, name,
|
2006-10-11 15:20:50 +07:00
|
|
|
end - (void *)entry, 0);
|
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
size = le32_to_cpu(entry->e_value_size);
|
|
|
|
if (buffer) {
|
|
|
|
error = -ERANGE;
|
|
|
|
if (size > buffer_size)
|
|
|
|
goto cleanup;
|
|
|
|
memcpy(buffer, (void *)IFIRST(header) +
|
|
|
|
le16_to_cpu(entry->e_value_offs), size);
|
|
|
|
}
|
|
|
|
error = size;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
brelse(iloc.bh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_xattr_get()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* Copy an extended attribute into the buffer
|
|
|
|
* provided, or compute the buffer size required.
|
|
|
|
* Buffer is NULL to compute the size of the buffer required.
|
|
|
|
*
|
|
|
|
* Returns a negative error number on failure, or the number of bytes
|
|
|
|
* used / required on success.
|
|
|
|
*/
|
|
|
|
int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_get(struct inode *inode, int name_index, const char *name,
|
2006-10-11 15:20:50 +07:00
|
|
|
void *buffer, size_t buffer_size)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2014-05-12 20:57:59 +07:00
|
|
|
if (strlen(name) > 255)
|
|
|
|
return -ERANGE;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
down_read(&EXT4_I(inode)->xattr_sem);
|
|
|
|
error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
|
2006-10-11 15:20:50 +07:00
|
|
|
buffer_size);
|
|
|
|
if (error == -ENODATA)
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_block_get(inode, name_index, name, buffer,
|
2006-10-11 15:20:50 +07:00
|
|
|
buffer_size);
|
2006-10-11 15:20:53 +07:00
|
|
|
up_read(&EXT4_I(inode)->xattr_sem);
|
2006-10-11 15:20:50 +07:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-11-13 16:52:56 +07:00
|
|
|
ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
|
2006-10-11 15:20:50 +07:00
|
|
|
char *buffer, size_t buffer_size)
|
|
|
|
{
|
|
|
|
size_t rest = buffer_size;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
|
2010-05-14 07:53:18 +07:00
|
|
|
const struct xattr_handler *handler =
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_handler(entry->e_name_index);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2015-12-02 20:44:43 +07:00
|
|
|
if (handler && (!handler->list || handler->list(dentry))) {
|
|
|
|
const char *prefix = handler->prefix ?: handler->name;
|
|
|
|
size_t prefix_len = strlen(prefix);
|
|
|
|
size_t size = prefix_len + entry->e_name_len + 1;
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
if (buffer) {
|
|
|
|
if (size > rest)
|
|
|
|
return -ERANGE;
|
2015-12-02 20:44:43 +07:00
|
|
|
memcpy(buffer, prefix, prefix_len);
|
|
|
|
buffer += prefix_len;
|
|
|
|
memcpy(buffer, entry->e_name, entry->e_name_len);
|
|
|
|
buffer += entry->e_name_len;
|
|
|
|
*buffer++ = 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
rest -= size;
|
|
|
|
}
|
|
|
|
}
|
2015-12-02 20:44:43 +07:00
|
|
|
return buffer_size - rest; /* total size */
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-11-13 16:52:56 +07:00
|
|
|
ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2015-03-18 05:25:59 +07:00
|
|
|
struct inode *inode = d_inode(dentry);
|
2006-10-11 15:20:50 +07:00
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
int error;
|
2016-02-23 10:35:22 +07:00
|
|
|
struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
ea_idebug(inode, "buffer=%p, buffer_size=%ld",
|
|
|
|
buffer, (long)buffer_size);
|
|
|
|
|
|
|
|
error = 0;
|
2006-10-11 15:20:53 +07:00
|
|
|
if (!EXT4_I(inode)->i_file_acl)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
2012-03-20 10:11:43 +07:00
|
|
|
ea_idebug(inode, "reading block %llu",
|
|
|
|
(unsigned long long)EXT4_I(inode)->i_file_acl);
|
2006-10-11 15:20:53 +07:00
|
|
|
bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
|
2006-10-11 15:20:50 +07:00
|
|
|
error = -EIO;
|
|
|
|
if (!bh)
|
|
|
|
goto cleanup;
|
|
|
|
ea_bdebug(bh, "b_count=%d, refcount=%d",
|
|
|
|
atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
|
2012-04-30 05:43:10 +07:00
|
|
|
if (ext4_xattr_check_block(inode, bh)) {
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(inode, "bad block %llu",
|
|
|
|
EXT4_I(inode)->i_file_acl);
|
2015-10-18 03:16:04 +07:00
|
|
|
error = -EFSCORRUPTED;
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2014-03-19 06:24:49 +07:00
|
|
|
ext4_xattr_cache_insert(ext4_mb_cache, bh);
|
2009-11-13 16:52:56 +07:00
|
|
|
error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer, buffer_size);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
brelse(bh);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-11-13 16:52:56 +07:00
|
|
|
ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2015-03-18 05:25:59 +07:00
|
|
|
struct inode *inode = d_inode(dentry);
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_ibody_header *header;
|
|
|
|
struct ext4_inode *raw_inode;
|
|
|
|
struct ext4_iloc iloc;
|
2006-10-11 15:20:50 +07:00
|
|
|
void *end;
|
|
|
|
int error;
|
|
|
|
|
2010-01-25 02:34:07 +07:00
|
|
|
if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
|
2006-10-11 15:20:50 +07:00
|
|
|
return 0;
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_get_inode_loc(inode, &iloc);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
return error;
|
2006-10-11 15:20:53 +07:00
|
|
|
raw_inode = ext4_raw_inode(&iloc);
|
2006-10-11 15:20:50 +07:00
|
|
|
header = IHDR(inode, raw_inode);
|
2006-10-11 15:20:53 +07:00
|
|
|
end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
|
2014-09-17 01:34:59 +07:00
|
|
|
error = ext4_xattr_check_names(IFIRST(header), end, IFIRST(header));
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
2009-11-13 16:52:56 +07:00
|
|
|
error = ext4_xattr_list_entries(dentry, IFIRST(header),
|
2006-10-11 15:20:50 +07:00
|
|
|
buffer, buffer_size);
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
brelse(iloc.bh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_xattr_list()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* Copy a list of attribute names into the buffer
|
|
|
|
* provided, or compute the buffer size required.
|
|
|
|
* Buffer is NULL to compute the size of the buffer required.
|
|
|
|
*
|
|
|
|
* Returns a negative error number on failure, or the number of bytes
|
|
|
|
* used / required on success.
|
|
|
|
*/
|
2008-04-17 21:38:59 +07:00
|
|
|
static int
|
2009-11-13 16:52:56 +07:00
|
|
|
ext4_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2011-01-11 00:10:07 +07:00
|
|
|
int ret, ret2;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2015-03-18 05:25:59 +07:00
|
|
|
down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
|
2011-01-11 00:10:07 +07:00
|
|
|
ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);
|
|
|
|
if (ret < 0)
|
|
|
|
goto errout;
|
|
|
|
if (buffer) {
|
|
|
|
buffer += ret;
|
|
|
|
buffer_size -= ret;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2011-01-11 00:10:07 +07:00
|
|
|
ret = ext4_xattr_block_list(dentry, buffer, buffer_size);
|
|
|
|
if (ret < 0)
|
|
|
|
goto errout;
|
|
|
|
ret += ret2;
|
|
|
|
errout:
|
2015-03-18 05:25:59 +07:00
|
|
|
up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
|
2011-01-11 00:10:07 +07:00
|
|
|
return ret;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* If the EXT4_FEATURE_COMPAT_EXT_ATTR feature of this file system is
|
2006-10-11 15:20:50 +07:00
|
|
|
* not set, set it.
|
|
|
|
*/
|
2006-10-11 15:20:53 +07:00
|
|
|
static void ext4_xattr_update_super_block(handle_t *handle,
|
2006-10-11 15:20:50 +07:00
|
|
|
struct super_block *sb)
|
|
|
|
{
|
2015-10-18 03:18:43 +07:00
|
|
|
if (ext4_has_feature_xattr(sb))
|
2006-10-11 15:20:50 +07:00
|
|
|
return;
|
|
|
|
|
2014-05-13 09:06:43 +07:00
|
|
|
BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
|
2006-10-11 15:20:53 +07:00
|
|
|
if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
|
2015-10-18 03:18:43 +07:00
|
|
|
ext4_set_feature_xattr(sb);
|
2010-06-12 10:14:04 +07:00
|
|
|
ext4_handle_dirty_super(handle, sb);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-04-07 21:54:21 +07:00
|
|
|
* Release the xattr block BH: If the reference count is > 1, decrement it;
|
|
|
|
* otherwise free the block.
|
2006-10-11 15:20:50 +07:00
|
|
|
*/
|
|
|
|
static void
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_release_block(handle_t *handle, struct inode *inode,
|
2006-10-11 15:20:50 +07:00
|
|
|
struct buffer_head *bh)
|
|
|
|
{
|
2016-02-23 10:44:04 +07:00
|
|
|
struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
|
|
|
|
u32 hash, ref;
|
2007-03-01 11:13:35 +07:00
|
|
|
int error = 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2014-05-13 09:06:43 +07:00
|
|
|
BUFFER_TRACE(bh, "get_write_access");
|
2007-03-01 11:13:35 +07:00
|
|
|
error = ext4_journal_get_write_access(handle, bh);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
lock_buffer(bh);
|
2016-02-23 10:44:04 +07:00
|
|
|
hash = le32_to_cpu(BHDR(bh)->h_hash);
|
|
|
|
ref = le32_to_cpu(BHDR(bh)->h_refcount);
|
|
|
|
if (ref == 1) {
|
2006-10-11 15:20:50 +07:00
|
|
|
ea_bdebug(bh, "refcount now=0; freeing");
|
2016-02-22 23:50:13 +07:00
|
|
|
/*
|
|
|
|
* This must happen under buffer lock for
|
|
|
|
* ext4_xattr_block_set() to reliably detect freed block
|
|
|
|
*/
|
2016-02-23 10:44:04 +07:00
|
|
|
mb_cache_entry_delete_block(ext4_mb_cache, hash, bh->b_blocknr);
|
2006-10-11 15:20:50 +07:00
|
|
|
get_bh(bh);
|
2014-04-07 21:54:21 +07:00
|
|
|
unlock_buffer(bh);
|
2009-11-23 19:17:05 +07:00
|
|
|
ext4_free_blocks(handle, inode, bh, 0, 1,
|
|
|
|
EXT4_FREE_BLOCKS_METADATA |
|
|
|
|
EXT4_FREE_BLOCKS_FORGET);
|
2006-10-11 15:20:50 +07:00
|
|
|
} else {
|
2016-02-23 10:44:04 +07:00
|
|
|
ref--;
|
|
|
|
BHDR(bh)->h_refcount = cpu_to_le32(ref);
|
|
|
|
if (ref == EXT4_XATTR_REFCOUNT_MAX - 1) {
|
|
|
|
struct mb_cache_entry *ce;
|
|
|
|
|
|
|
|
ce = mb_cache_entry_get(ext4_mb_cache, hash,
|
|
|
|
bh->b_blocknr);
|
|
|
|
if (ce) {
|
|
|
|
ce->e_reusable = 1;
|
|
|
|
mb_cache_entry_put(ext4_mb_cache, ce);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-07 21:54:21 +07:00
|
|
|
/*
|
|
|
|
* Beware of this ugliness: Releasing of xattr block references
|
|
|
|
* from different inodes can race and so we have to protect
|
|
|
|
* from a race where someone else frees the block (and releases
|
|
|
|
* its journal_head) before we are done dirtying the buffer. In
|
|
|
|
* nojournal mode this race is harmless and we actually cannot
|
|
|
|
* call ext4_handle_dirty_xattr_block() with locked buffer as
|
|
|
|
* that function can call sync_dirty_buffer() so for that case
|
|
|
|
* we handle the dirtying after unlocking the buffer.
|
|
|
|
*/
|
|
|
|
if (ext4_handle_valid(handle))
|
|
|
|
error = ext4_handle_dirty_xattr_block(handle, inode,
|
|
|
|
bh);
|
2012-02-21 11:06:18 +07:00
|
|
|
unlock_buffer(bh);
|
2014-04-07 21:54:21 +07:00
|
|
|
if (!ext4_handle_valid(handle))
|
|
|
|
error = ext4_handle_dirty_xattr_block(handle, inode,
|
|
|
|
bh);
|
2007-03-01 11:13:35 +07:00
|
|
|
if (IS_SYNC(inode))
|
2009-01-07 12:06:22 +07:00
|
|
|
ext4_handle_sync(handle);
|
2013-02-19 00:12:07 +07:00
|
|
|
dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1));
|
2007-03-01 11:13:35 +07:00
|
|
|
ea_bdebug(bh, "refcount now=%d; releasing",
|
|
|
|
le32_to_cpu(BHDR(bh)->h_refcount));
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2007-03-01 11:13:35 +07:00
|
|
|
out:
|
|
|
|
ext4_std_error(inode->i_sb, error);
|
|
|
|
return;
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
2007-07-18 20:19:57 +07:00
|
|
|
/*
|
|
|
|
* Find the available free space for EAs. This also returns the total number of
|
|
|
|
* bytes used by EA entries.
|
|
|
|
*/
|
|
|
|
static size_t ext4_xattr_free_space(struct ext4_xattr_entry *last,
|
|
|
|
size_t *min_offs, void *base, int *total)
|
|
|
|
{
|
|
|
|
for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
|
|
|
|
if (!last->e_value_block && last->e_value_size) {
|
|
|
|
size_t offs = le16_to_cpu(last->e_value_offs);
|
|
|
|
if (offs < *min_offs)
|
|
|
|
*min_offs = offs;
|
|
|
|
}
|
2014-02-20 08:15:21 +07:00
|
|
|
if (total)
|
|
|
|
*total += EXT4_XATTR_LEN(last->e_name_len);
|
2007-07-18 20:19:57 +07:00
|
|
|
}
|
|
|
|
return (*min_offs - ((void *)last - base) - sizeof(__u32));
|
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
static int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_set_entry(struct ext4_xattr_info *i, struct ext4_xattr_search *s)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_entry *last;
|
2006-10-11 15:20:50 +07:00
|
|
|
size_t free, min_offs = s->end - s->base, name_len = strlen(i->name);
|
|
|
|
|
|
|
|
/* Compute min_offs and last. */
|
|
|
|
last = s->first;
|
2006-10-11 15:20:53 +07:00
|
|
|
for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!last->e_value_block && last->e_value_size) {
|
|
|
|
size_t offs = le16_to_cpu(last->e_value_offs);
|
|
|
|
if (offs < min_offs)
|
|
|
|
min_offs = offs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free = min_offs - ((void *)last - s->base) - sizeof(__u32);
|
|
|
|
if (!s->not_found) {
|
|
|
|
if (!s->here->e_value_block && s->here->e_value_size) {
|
|
|
|
size_t size = le32_to_cpu(s->here->e_value_size);
|
2006-10-11 15:20:53 +07:00
|
|
|
free += EXT4_XATTR_SIZE(size);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
free += EXT4_XATTR_LEN(name_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
if (i->value) {
|
2015-04-03 10:50:48 +07:00
|
|
|
if (free < EXT4_XATTR_LEN(name_len) +
|
2006-10-11 15:20:53 +07:00
|
|
|
EXT4_XATTR_SIZE(i->value_len))
|
2006-10-11 15:20:50 +07:00
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i->value && s->not_found) {
|
|
|
|
/* Insert the new name. */
|
2006-10-11 15:20:53 +07:00
|
|
|
size_t size = EXT4_XATTR_LEN(name_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
size_t rest = (void *)last - (void *)s->here + sizeof(__u32);
|
|
|
|
memmove((void *)s->here + size, s->here, rest);
|
|
|
|
memset(s->here, 0, size);
|
|
|
|
s->here->e_name_index = i->name_index;
|
|
|
|
s->here->e_name_len = name_len;
|
|
|
|
memcpy(s->here->e_name, i->name, name_len);
|
|
|
|
} else {
|
|
|
|
if (!s->here->e_value_block && s->here->e_value_size) {
|
|
|
|
void *first_val = s->base + min_offs;
|
|
|
|
size_t offs = le16_to_cpu(s->here->e_value_offs);
|
|
|
|
void *val = s->base + offs;
|
2006-10-11 15:20:53 +07:00
|
|
|
size_t size = EXT4_XATTR_SIZE(
|
2006-10-11 15:20:50 +07:00
|
|
|
le32_to_cpu(s->here->e_value_size));
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
if (i->value && size == EXT4_XATTR_SIZE(i->value_len)) {
|
2006-10-11 15:20:50 +07:00
|
|
|
/* The old and the new value have the same
|
|
|
|
size. Just replace. */
|
|
|
|
s->here->e_value_size =
|
|
|
|
cpu_to_le32(i->value_len);
|
2012-12-11 15:31:49 +07:00
|
|
|
if (i->value == EXT4_ZERO_XATTR_VALUE) {
|
|
|
|
memset(val, 0, size);
|
|
|
|
} else {
|
|
|
|
/* Clear pad bytes first. */
|
|
|
|
memset(val + size - EXT4_XATTR_PAD, 0,
|
|
|
|
EXT4_XATTR_PAD);
|
|
|
|
memcpy(val, i->value, i->value_len);
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove the old value. */
|
|
|
|
memmove(first_val + size, first_val, val - first_val);
|
|
|
|
memset(first_val, 0, size);
|
|
|
|
s->here->e_value_size = 0;
|
|
|
|
s->here->e_value_offs = 0;
|
|
|
|
min_offs += size;
|
|
|
|
|
|
|
|
/* Adjust all value offsets. */
|
|
|
|
last = s->first;
|
|
|
|
while (!IS_LAST_ENTRY(last)) {
|
|
|
|
size_t o = le16_to_cpu(last->e_value_offs);
|
|
|
|
if (!last->e_value_block &&
|
|
|
|
last->e_value_size && o < offs)
|
|
|
|
last->e_value_offs =
|
|
|
|
cpu_to_le16(o + size);
|
2006-10-11 15:20:53 +07:00
|
|
|
last = EXT4_XATTR_NEXT(last);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!i->value) {
|
|
|
|
/* Remove the old name. */
|
2006-10-11 15:20:53 +07:00
|
|
|
size_t size = EXT4_XATTR_LEN(name_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
last = ENTRY((void *)last - size);
|
|
|
|
memmove(s->here, (void *)s->here + size,
|
|
|
|
(void *)last - (void *)s->here + sizeof(__u32));
|
|
|
|
memset(last, 0, size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i->value) {
|
|
|
|
/* Insert the new value. */
|
|
|
|
s->here->e_value_size = cpu_to_le32(i->value_len);
|
|
|
|
if (i->value_len) {
|
2006-10-11 15:20:53 +07:00
|
|
|
size_t size = EXT4_XATTR_SIZE(i->value_len);
|
2006-10-11 15:20:50 +07:00
|
|
|
void *val = s->base + min_offs - size;
|
|
|
|
s->here->e_value_offs = cpu_to_le16(min_offs - size);
|
2012-12-11 15:31:49 +07:00
|
|
|
if (i->value == EXT4_ZERO_XATTR_VALUE) {
|
|
|
|
memset(val, 0, size);
|
|
|
|
} else {
|
|
|
|
/* Clear the pad bytes first. */
|
|
|
|
memset(val + size - EXT4_XATTR_PAD, 0,
|
|
|
|
EXT4_XATTR_PAD);
|
|
|
|
memcpy(val, i->value, i->value_len);
|
|
|
|
}
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_block_find {
|
|
|
|
struct ext4_xattr_search s;
|
2006-10-11 15:20:50 +07:00
|
|
|
struct buffer_head *bh;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
|
|
|
|
struct ext4_xattr_block_find *bs)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
|
|
|
|
i->name_index, i->name, i->value, (long)i->value_len);
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
if (EXT4_I(inode)->i_file_acl) {
|
2006-10-11 15:20:50 +07:00
|
|
|
/* The inode already has an extended attribute block. */
|
2006-10-11 15:20:53 +07:00
|
|
|
bs->bh = sb_bread(sb, EXT4_I(inode)->i_file_acl);
|
2006-10-11 15:20:50 +07:00
|
|
|
error = -EIO;
|
|
|
|
if (!bs->bh)
|
|
|
|
goto cleanup;
|
|
|
|
ea_bdebug(bs->bh, "b_count=%d, refcount=%d",
|
|
|
|
atomic_read(&(bs->bh->b_count)),
|
|
|
|
le32_to_cpu(BHDR(bs->bh)->h_refcount));
|
2012-04-30 05:43:10 +07:00
|
|
|
if (ext4_xattr_check_block(inode, bs->bh)) {
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(inode, "bad block %llu",
|
|
|
|
EXT4_I(inode)->i_file_acl);
|
2015-10-18 03:16:04 +07:00
|
|
|
error = -EFSCORRUPTED;
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
/* Find the named attribute. */
|
|
|
|
bs->s.base = BHDR(bs->bh);
|
|
|
|
bs->s.first = BFIRST(bs->bh);
|
|
|
|
bs->s.end = bs->bh->b_data + bs->bh->b_size;
|
|
|
|
bs->s.here = bs->s.first;
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_find_entry(&bs->s.here, i->name_index,
|
2006-10-11 15:20:50 +07:00
|
|
|
i->name, bs->bh->b_size, 1);
|
|
|
|
if (error && error != -ENODATA)
|
|
|
|
goto cleanup;
|
|
|
|
bs->s.not_found = error;
|
|
|
|
}
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_block_set(handle_t *handle, struct inode *inode,
|
|
|
|
struct ext4_xattr_info *i,
|
|
|
|
struct ext4_xattr_block_find *bs)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
struct buffer_head *new_bh = NULL;
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_search *s = &bs->s;
|
2016-02-23 10:35:22 +07:00
|
|
|
struct mb_cache_entry *ce = NULL;
|
2007-03-01 11:13:35 +07:00
|
|
|
int error = 0;
|
2016-02-23 10:35:22 +07:00
|
|
|
struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
#define header(x) ((struct ext4_xattr_header *)(x))
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
if (i->value && i->value_len > sb->s_blocksize)
|
|
|
|
return -ENOSPC;
|
|
|
|
if (s->base) {
|
2014-05-13 09:06:43 +07:00
|
|
|
BUFFER_TRACE(bs->bh, "get_write_access");
|
2007-03-01 11:13:35 +07:00
|
|
|
error = ext4_journal_get_write_access(handle, bs->bh);
|
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
lock_buffer(bs->bh);
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
if (header(s->base)->h_refcount == cpu_to_le32(1)) {
|
2016-02-22 23:50:13 +07:00
|
|
|
__u32 hash = le32_to_cpu(BHDR(bs->bh)->h_hash);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This must happen under buffer lock for
|
|
|
|
* ext4_xattr_block_set() to reliably detect modified
|
|
|
|
* block
|
|
|
|
*/
|
2016-02-23 10:35:22 +07:00
|
|
|
mb_cache_entry_delete_block(ext4_mb_cache, hash,
|
|
|
|
bs->bh->b_blocknr);
|
2006-10-11 15:20:50 +07:00
|
|
|
ea_bdebug(bs->bh, "modifying in-place");
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_set_entry(i, s);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!error) {
|
|
|
|
if (!IS_LAST_ENTRY(s->first))
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_rehash(header(s->base),
|
2006-10-11 15:20:50 +07:00
|
|
|
s->here);
|
2014-03-19 06:24:49 +07:00
|
|
|
ext4_xattr_cache_insert(ext4_mb_cache,
|
|
|
|
bs->bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
unlock_buffer(bs->bh);
|
2015-10-18 03:16:04 +07:00
|
|
|
if (error == -EFSCORRUPTED)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto bad_block;
|
|
|
|
if (!error)
|
2012-04-30 05:43:10 +07:00
|
|
|
error = ext4_handle_dirty_xattr_block(handle,
|
|
|
|
inode,
|
|
|
|
bs->bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
goto inserted;
|
|
|
|
} else {
|
|
|
|
int offset = (char *)s->here - bs->bh->b_data;
|
|
|
|
|
2007-03-01 11:13:35 +07:00
|
|
|
unlock_buffer(bs->bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
ea_bdebug(bs->bh, "cloning");
|
2008-04-30 09:02:02 +07:00
|
|
|
s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
|
2006-10-11 15:20:50 +07:00
|
|
|
error = -ENOMEM;
|
|
|
|
if (s->base == NULL)
|
|
|
|
goto cleanup;
|
|
|
|
memcpy(s->base, BHDR(bs->bh), bs->bh->b_size);
|
|
|
|
s->first = ENTRY(header(s->base)+1);
|
|
|
|
header(s->base)->h_refcount = cpu_to_le32(1);
|
|
|
|
s->here = ENTRY(s->base + offset);
|
|
|
|
s->end = s->base + bs->bh->b_size;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Allocate a buffer where we construct the new block. */
|
2008-04-30 09:02:02 +07:00
|
|
|
s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
|
2006-10-11 15:20:50 +07:00
|
|
|
/* assert(header == s->base) */
|
|
|
|
error = -ENOMEM;
|
|
|
|
if (s->base == NULL)
|
|
|
|
goto cleanup;
|
2006-10-11 15:20:53 +07:00
|
|
|
header(s->base)->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
|
2006-10-11 15:20:50 +07:00
|
|
|
header(s->base)->h_blocks = cpu_to_le32(1);
|
|
|
|
header(s->base)->h_refcount = cpu_to_le32(1);
|
|
|
|
s->first = ENTRY(header(s->base)+1);
|
|
|
|
s->here = ENTRY(header(s->base)+1);
|
|
|
|
s->end = s->base + sb->s_blocksize;
|
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_set_entry(i, s);
|
2015-10-18 03:16:04 +07:00
|
|
|
if (error == -EFSCORRUPTED)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto bad_block;
|
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
if (!IS_LAST_ENTRY(s->first))
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_rehash(header(s->base), s->here);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
inserted:
|
|
|
|
if (!IS_LAST_ENTRY(s->first)) {
|
2006-10-11 15:20:53 +07:00
|
|
|
new_bh = ext4_xattr_cache_find(inode, header(s->base), &ce);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (new_bh) {
|
|
|
|
/* We found an identical block in the cache. */
|
|
|
|
if (new_bh == bs->bh)
|
|
|
|
ea_bdebug(new_bh, "keeping");
|
|
|
|
else {
|
2016-02-23 10:44:04 +07:00
|
|
|
u32 ref;
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/* The old block is released after updating
|
|
|
|
the inode. */
|
2013-02-19 00:12:07 +07:00
|
|
|
error = dquot_alloc_block(inode,
|
|
|
|
EXT4_C2B(EXT4_SB(sb), 1));
|
2010-03-03 21:05:00 +07:00
|
|
|
if (error)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
2014-05-13 09:06:43 +07:00
|
|
|
BUFFER_TRACE(new_bh, "get_write_access");
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_journal_get_write_access(handle,
|
2006-10-11 15:20:50 +07:00
|
|
|
new_bh);
|
|
|
|
if (error)
|
|
|
|
goto cleanup_dquot;
|
|
|
|
lock_buffer(new_bh);
|
2016-02-22 23:50:13 +07:00
|
|
|
/*
|
|
|
|
* We have to be careful about races with
|
2016-02-23 10:44:04 +07:00
|
|
|
* freeing, rehashing or adding references to
|
|
|
|
* xattr block. Once we hold buffer lock xattr
|
|
|
|
* block's state is stable so we can check
|
|
|
|
* whether the block got freed / rehashed or
|
|
|
|
* not. Since we unhash mbcache entry under
|
|
|
|
* buffer lock when freeing / rehashing xattr
|
|
|
|
* block, checking whether entry is still
|
|
|
|
* hashed is reliable. Same rules hold for
|
|
|
|
* e_reusable handling.
|
2016-02-22 23:50:13 +07:00
|
|
|
*/
|
2016-02-23 10:44:04 +07:00
|
|
|
if (hlist_bl_unhashed(&ce->e_hash_list) ||
|
|
|
|
!ce->e_reusable) {
|
2016-02-22 23:50:13 +07:00
|
|
|
/*
|
|
|
|
* Undo everything and check mbcache
|
|
|
|
* again.
|
|
|
|
*/
|
|
|
|
unlock_buffer(new_bh);
|
|
|
|
dquot_free_block(inode,
|
|
|
|
EXT4_C2B(EXT4_SB(sb),
|
|
|
|
1));
|
|
|
|
brelse(new_bh);
|
2016-02-23 10:35:22 +07:00
|
|
|
mb_cache_entry_put(ext4_mb_cache, ce);
|
2016-02-22 23:50:13 +07:00
|
|
|
ce = NULL;
|
|
|
|
new_bh = NULL;
|
|
|
|
goto inserted;
|
|
|
|
}
|
2016-02-23 10:44:04 +07:00
|
|
|
ref = le32_to_cpu(BHDR(new_bh)->h_refcount) + 1;
|
|
|
|
BHDR(new_bh)->h_refcount = cpu_to_le32(ref);
|
|
|
|
if (ref >= EXT4_XATTR_REFCOUNT_MAX)
|
|
|
|
ce->e_reusable = 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
ea_bdebug(new_bh, "reusing; refcount now=%d",
|
2016-02-23 10:44:04 +07:00
|
|
|
ref);
|
2006-10-11 15:20:50 +07:00
|
|
|
unlock_buffer(new_bh);
|
2012-04-30 05:43:10 +07:00
|
|
|
error = ext4_handle_dirty_xattr_block(handle,
|
|
|
|
inode,
|
|
|
|
new_bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup_dquot;
|
|
|
|
}
|
2016-02-23 10:35:22 +07:00
|
|
|
mb_cache_entry_touch(ext4_mb_cache, ce);
|
|
|
|
mb_cache_entry_put(ext4_mb_cache, ce);
|
2006-10-11 15:20:50 +07:00
|
|
|
ce = NULL;
|
|
|
|
} else if (bs->bh && s->base == bs->bh->b_data) {
|
|
|
|
/* We were modifying this block in-place. */
|
|
|
|
ea_bdebug(bs->bh, "keeping this block");
|
|
|
|
new_bh = bs->bh;
|
|
|
|
get_bh(new_bh);
|
|
|
|
} else {
|
|
|
|
/* We need to allocate a new block */
|
ext4: limit block allocations for indirect-block files to < 2^32
Today, the ext4 allocator will happily allocate blocks past
2^32 for indirect-block files, which results in the block
numbers getting truncated, and corruption ensues.
This patch limits such allocations to < 2^32, and adds
BUG_ONs if we do get blocks larger than that.
This should address RH Bug 519471, ext4 bitmap allocator
must limit blocks to < 2^32
* ext4_find_goal() is modified to choose a goal < UINT_MAX,
so that our starting point is in an acceptable range.
* ext4_xattr_block_set() is modified such that the goal block
is < UINT_MAX, as above.
* ext4_mb_regular_allocator() is modified so that the group
search does not continue into groups which are too high
* ext4_mb_use_preallocated() has a check that we don't use
preallocated space which is too far out
* ext4_alloc_blocks() and ext4_xattr_block_set() add some BUG_ONs
No attempt has been made to limit inode locations to < 2^32,
so we may wind up with blocks far from their inodes. Doing
this much already will lead to some odd ENOSPC issues when the
"lower 32" gets full, and further restricting inodes could
make that even weirder.
For high inodes, choosing a goal of the original, % UINT_MAX,
may be a bit odd, but then we're in an odd situation anyway,
and I don't know of a better heuristic.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-17 01:45:10 +07:00
|
|
|
ext4_fsblk_t goal, block;
|
|
|
|
|
|
|
|
goal = ext4_group_first_block_no(sb,
|
2008-04-17 21:38:59 +07:00
|
|
|
EXT4_I(inode)->i_block_group);
|
ext4: limit block allocations for indirect-block files to < 2^32
Today, the ext4 allocator will happily allocate blocks past
2^32 for indirect-block files, which results in the block
numbers getting truncated, and corruption ensues.
This patch limits such allocations to < 2^32, and adds
BUG_ONs if we do get blocks larger than that.
This should address RH Bug 519471, ext4 bitmap allocator
must limit blocks to < 2^32
* ext4_find_goal() is modified to choose a goal < UINT_MAX,
so that our starting point is in an acceptable range.
* ext4_xattr_block_set() is modified such that the goal block
is < UINT_MAX, as above.
* ext4_mb_regular_allocator() is modified so that the group
search does not continue into groups which are too high
* ext4_mb_use_preallocated() has a check that we don't use
preallocated space which is too far out
* ext4_alloc_blocks() and ext4_xattr_block_set() add some BUG_ONs
No attempt has been made to limit inode locations to < 2^32,
so we may wind up with blocks far from their inodes. Doing
this much already will lead to some odd ENOSPC issues when the
"lower 32" gets full, and further restricting inodes could
make that even weirder.
For high inodes, choosing a goal of the original, % UINT_MAX,
may be a bit odd, but then we're in an odd situation anyway,
and I don't know of a better heuristic.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-17 01:45:10 +07:00
|
|
|
|
|
|
|
/* non-extent files can't have physical blocks past 2^32 */
|
2010-05-17 09:00:00 +07:00
|
|
|
if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
|
ext4: limit block allocations for indirect-block files to < 2^32
Today, the ext4 allocator will happily allocate blocks past
2^32 for indirect-block files, which results in the block
numbers getting truncated, and corruption ensues.
This patch limits such allocations to < 2^32, and adds
BUG_ONs if we do get blocks larger than that.
This should address RH Bug 519471, ext4 bitmap allocator
must limit blocks to < 2^32
* ext4_find_goal() is modified to choose a goal < UINT_MAX,
so that our starting point is in an acceptable range.
* ext4_xattr_block_set() is modified such that the goal block
is < UINT_MAX, as above.
* ext4_mb_regular_allocator() is modified so that the group
search does not continue into groups which are too high
* ext4_mb_use_preallocated() has a check that we don't use
preallocated space which is too far out
* ext4_alloc_blocks() and ext4_xattr_block_set() add some BUG_ONs
No attempt has been made to limit inode locations to < 2^32,
so we may wind up with blocks far from their inodes. Doing
this much already will lead to some odd ENOSPC issues when the
"lower 32" gets full, and further restricting inodes could
make that even weirder.
For high inodes, choosing a goal of the original, % UINT_MAX,
may be a bit odd, but then we're in an odd situation anyway,
and I don't know of a better heuristic.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-17 01:45:10 +07:00
|
|
|
goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
|
|
|
|
|
2011-05-25 18:41:26 +07:00
|
|
|
block = ext4_new_meta_blocks(handle, inode, goal, 0,
|
|
|
|
NULL, &error);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
ext4: limit block allocations for indirect-block files to < 2^32
Today, the ext4 allocator will happily allocate blocks past
2^32 for indirect-block files, which results in the block
numbers getting truncated, and corruption ensues.
This patch limits such allocations to < 2^32, and adds
BUG_ONs if we do get blocks larger than that.
This should address RH Bug 519471, ext4 bitmap allocator
must limit blocks to < 2^32
* ext4_find_goal() is modified to choose a goal < UINT_MAX,
so that our starting point is in an acceptable range.
* ext4_xattr_block_set() is modified such that the goal block
is < UINT_MAX, as above.
* ext4_mb_regular_allocator() is modified so that the group
search does not continue into groups which are too high
* ext4_mb_use_preallocated() has a check that we don't use
preallocated space which is too far out
* ext4_alloc_blocks() and ext4_xattr_block_set() add some BUG_ONs
No attempt has been made to limit inode locations to < 2^32,
so we may wind up with blocks far from their inodes. Doing
this much already will lead to some odd ENOSPC issues when the
"lower 32" gets full, and further restricting inodes could
make that even weirder.
For high inodes, choosing a goal of the original, % UINT_MAX,
may be a bit odd, but then we're in an odd situation anyway,
and I don't know of a better heuristic.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-17 01:45:10 +07:00
|
|
|
|
2010-05-17 09:00:00 +07:00
|
|
|
if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
|
ext4: limit block allocations for indirect-block files to < 2^32
Today, the ext4 allocator will happily allocate blocks past
2^32 for indirect-block files, which results in the block
numbers getting truncated, and corruption ensues.
This patch limits such allocations to < 2^32, and adds
BUG_ONs if we do get blocks larger than that.
This should address RH Bug 519471, ext4 bitmap allocator
must limit blocks to < 2^32
* ext4_find_goal() is modified to choose a goal < UINT_MAX,
so that our starting point is in an acceptable range.
* ext4_xattr_block_set() is modified such that the goal block
is < UINT_MAX, as above.
* ext4_mb_regular_allocator() is modified so that the group
search does not continue into groups which are too high
* ext4_mb_use_preallocated() has a check that we don't use
preallocated space which is too far out
* ext4_alloc_blocks() and ext4_xattr_block_set() add some BUG_ONs
No attempt has been made to limit inode locations to < 2^32,
so we may wind up with blocks far from their inodes. Doing
this much already will lead to some odd ENOSPC issues when the
"lower 32" gets full, and further restricting inodes could
make that even weirder.
For high inodes, choosing a goal of the original, % UINT_MAX,
may be a bit odd, but then we're in an odd situation anyway,
and I don't know of a better heuristic.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2009-09-17 01:45:10 +07:00
|
|
|
BUG_ON(block > EXT4_MAX_BLOCK_FILE_PHYS);
|
|
|
|
|
2012-03-20 10:11:43 +07:00
|
|
|
ea_idebug(inode, "creating block %llu",
|
|
|
|
(unsigned long long)block);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
new_bh = sb_getblk(sb, block);
|
2013-01-13 04:28:47 +07:00
|
|
|
if (unlikely(!new_bh)) {
|
2013-01-13 04:19:36 +07:00
|
|
|
error = -ENOMEM;
|
2006-10-11 15:20:50 +07:00
|
|
|
getblk_failed:
|
2011-02-22 09:01:42 +07:00
|
|
|
ext4_free_blocks(handle, inode, NULL, block, 1,
|
2009-11-23 19:17:05 +07:00
|
|
|
EXT4_FREE_BLOCKS_METADATA);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
lock_buffer(new_bh);
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_journal_get_create_access(handle, new_bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error) {
|
|
|
|
unlock_buffer(new_bh);
|
2013-01-13 04:19:36 +07:00
|
|
|
error = -EIO;
|
2006-10-11 15:20:50 +07:00
|
|
|
goto getblk_failed;
|
|
|
|
}
|
|
|
|
memcpy(new_bh->b_data, s->base, new_bh->b_size);
|
|
|
|
set_buffer_uptodate(new_bh);
|
|
|
|
unlock_buffer(new_bh);
|
2014-03-19 06:24:49 +07:00
|
|
|
ext4_xattr_cache_insert(ext4_mb_cache, new_bh);
|
2012-04-30 05:43:10 +07:00
|
|
|
error = ext4_handle_dirty_xattr_block(handle,
|
|
|
|
inode, new_bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update the inode. */
|
2006-10-11 15:20:53 +07:00
|
|
|
EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
/* Drop the previous xattr block. */
|
|
|
|
if (bs->bh && bs->bh != new_bh)
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_release_block(handle, inode, bs->bh);
|
2006-10-11 15:20:50 +07:00
|
|
|
error = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (ce)
|
2016-02-23 10:35:22 +07:00
|
|
|
mb_cache_entry_put(ext4_mb_cache, ce);
|
2006-10-11 15:20:50 +07:00
|
|
|
brelse(new_bh);
|
|
|
|
if (!(bs->bh && s->base == bs->bh->b_data))
|
|
|
|
kfree(s->base);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
|
|
|
|
cleanup_dquot:
|
2013-02-19 00:12:07 +07:00
|
|
|
dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb), 1));
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
bad_block:
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(inode, "bad block %llu",
|
|
|
|
EXT4_I(inode)->i_file_acl);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
#undef header
|
|
|
|
}
|
|
|
|
|
2012-12-05 22:28:46 +07:00
|
|
|
int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
|
|
|
|
struct ext4_xattr_ibody_find *is)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_ibody_header *header;
|
|
|
|
struct ext4_inode *raw_inode;
|
2006-10-11 15:20:50 +07:00
|
|
|
int error;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
if (EXT4_I(inode)->i_extra_isize == 0)
|
2006-10-11 15:20:50 +07:00
|
|
|
return 0;
|
2006-10-11 15:20:53 +07:00
|
|
|
raw_inode = ext4_raw_inode(&is->iloc);
|
2006-10-11 15:20:50 +07:00
|
|
|
header = IHDR(inode, raw_inode);
|
|
|
|
is->s.base = is->s.first = IFIRST(header);
|
|
|
|
is->s.here = is->s.first;
|
2006-10-11 15:20:53 +07:00
|
|
|
is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
|
2010-01-25 02:34:07 +07:00
|
|
|
if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
|
2014-09-17 01:34:59 +07:00
|
|
|
error = ext4_xattr_check_names(IFIRST(header), is->s.end,
|
|
|
|
IFIRST(header));
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
/* Find the named attribute. */
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_find_entry(&is->s.here, i->name_index,
|
2006-10-11 15:20:50 +07:00
|
|
|
i->name, is->s.end -
|
|
|
|
(void *)is->s.base, 0);
|
|
|
|
if (error && error != -ENODATA)
|
|
|
|
return error;
|
|
|
|
is->s.not_found = error;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-12-11 02:06:02 +07:00
|
|
|
int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode,
|
|
|
|
struct ext4_xattr_info *i,
|
|
|
|
struct ext4_xattr_ibody_find *is)
|
|
|
|
{
|
|
|
|
struct ext4_xattr_ibody_header *header;
|
|
|
|
struct ext4_xattr_search *s = &is->s;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (EXT4_I(inode)->i_extra_isize == 0)
|
|
|
|
return -ENOSPC;
|
|
|
|
error = ext4_xattr_set_entry(i, s);
|
|
|
|
if (error) {
|
|
|
|
if (error == -ENOSPC &&
|
|
|
|
ext4_has_inline_data(inode)) {
|
|
|
|
error = ext4_try_to_evict_inline_data(handle, inode,
|
|
|
|
EXT4_XATTR_LEN(strlen(i->name) +
|
|
|
|
EXT4_XATTR_SIZE(i->value_len)));
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
error = ext4_xattr_ibody_find(inode, i, is);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
error = ext4_xattr_set_entry(i, s);
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
header = IHDR(inode, ext4_raw_inode(&is->iloc));
|
|
|
|
if (!IS_LAST_ENTRY(s->first)) {
|
|
|
|
header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
|
|
|
|
ext4_set_inode_state(inode, EXT4_STATE_XATTR);
|
|
|
|
} else {
|
|
|
|
header->h_magic = cpu_to_le32(0);
|
|
|
|
ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
|
|
|
|
struct ext4_xattr_info *i,
|
|
|
|
struct ext4_xattr_ibody_find *is)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_ibody_header *header;
|
|
|
|
struct ext4_xattr_search *s = &is->s;
|
2006-10-11 15:20:50 +07:00
|
|
|
int error;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
if (EXT4_I(inode)->i_extra_isize == 0)
|
2006-10-11 15:20:50 +07:00
|
|
|
return -ENOSPC;
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_set_entry(i, s);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
return error;
|
2006-10-11 15:20:53 +07:00
|
|
|
header = IHDR(inode, ext4_raw_inode(&is->iloc));
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!IS_LAST_ENTRY(s->first)) {
|
2006-10-11 15:20:53 +07:00
|
|
|
header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC);
|
2010-01-25 02:34:07 +07:00
|
|
|
ext4_set_inode_state(inode, EXT4_STATE_XATTR);
|
2006-10-11 15:20:50 +07:00
|
|
|
} else {
|
|
|
|
header->h_magic = cpu_to_le32(0);
|
2010-01-25 02:34:07 +07:00
|
|
|
ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-23 10:43:04 +07:00
|
|
|
static int ext4_xattr_value_same(struct ext4_xattr_search *s,
|
|
|
|
struct ext4_xattr_info *i)
|
|
|
|
{
|
|
|
|
void *value;
|
|
|
|
|
|
|
|
if (le32_to_cpu(s->here->e_value_size) != i->value_len)
|
|
|
|
return 0;
|
|
|
|
value = ((void *)s->base) + le16_to_cpu(s->here->e_value_offs);
|
|
|
|
return !memcmp(value, i->value, i->value_len);
|
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_xattr_set_handle()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
2011-01-11 00:10:30 +07:00
|
|
|
* Create, replace or remove an extended attribute for this inode. Value
|
2006-10-11 15:20:50 +07:00
|
|
|
* is NULL to remove an existing extended attribute, and non-NULL to
|
|
|
|
* either replace an existing extended attribute, or create a new extended
|
|
|
|
* attribute. The flags XATTR_REPLACE and XATTR_CREATE
|
|
|
|
* specify that an extended attribute must exist and must not exist
|
|
|
|
* previous to the call, respectively.
|
|
|
|
*
|
|
|
|
* Returns 0, or a negative error number on failure.
|
|
|
|
*/
|
|
|
|
int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
|
2006-10-11 15:20:50 +07:00
|
|
|
const char *name, const void *value, size_t value_len,
|
|
|
|
int flags)
|
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_info i = {
|
2006-10-11 15:20:50 +07:00
|
|
|
.name_index = name_index,
|
|
|
|
.name = name,
|
|
|
|
.value = value,
|
|
|
|
.value_len = value_len,
|
|
|
|
|
|
|
|
};
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_ibody_find is = {
|
2006-10-11 15:20:50 +07:00
|
|
|
.s = { .not_found = -ENODATA, },
|
|
|
|
};
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_block_find bs = {
|
2006-10-11 15:20:50 +07:00
|
|
|
.s = { .not_found = -ENODATA, },
|
|
|
|
};
|
2008-10-09 10:21:54 +07:00
|
|
|
unsigned long no_expand;
|
2006-10-11 15:20:50 +07:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
return -EINVAL;
|
|
|
|
if (strlen(name) > 255)
|
|
|
|
return -ERANGE;
|
2006-10-11 15:20:53 +07:00
|
|
|
down_write(&EXT4_I(inode)->xattr_sem);
|
2010-01-25 02:34:07 +07:00
|
|
|
no_expand = ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND);
|
|
|
|
ext4_set_inode_state(inode, EXT4_STATE_NO_EXPAND);
|
2008-10-09 10:21:54 +07:00
|
|
|
|
2011-10-26 14:32:07 +07:00
|
|
|
error = ext4_reserve_inode_write(handle, inode, &is.iloc);
|
2009-11-16 03:30:52 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
|
2010-01-25 02:34:07 +07:00
|
|
|
if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_inode *raw_inode = ext4_raw_inode(&is.iloc);
|
|
|
|
memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
|
2010-01-25 02:34:07 +07:00
|
|
|
ext4_clear_inode_state(inode, EXT4_STATE_NEW);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_ibody_find(inode, &i, &is);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
if (is.s.not_found)
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_block_find(inode, &i, &bs);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
if (is.s.not_found && bs.s.not_found) {
|
|
|
|
error = -ENODATA;
|
|
|
|
if (flags & XATTR_REPLACE)
|
|
|
|
goto cleanup;
|
|
|
|
error = 0;
|
|
|
|
if (!value)
|
|
|
|
goto cleanup;
|
|
|
|
} else {
|
|
|
|
error = -EEXIST;
|
|
|
|
if (flags & XATTR_CREATE)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
if (!value) {
|
|
|
|
if (!is.s.not_found)
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_ibody_set(handle, inode, &i, &is);
|
2006-10-11 15:20:50 +07:00
|
|
|
else if (!bs.s.not_found)
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_block_set(handle, inode, &i, &bs);
|
2006-10-11 15:20:50 +07:00
|
|
|
} else {
|
2016-02-23 10:43:04 +07:00
|
|
|
error = 0;
|
|
|
|
/* Xattr value did not change? Save us some work and bail out */
|
|
|
|
if (!is.s.not_found && ext4_xattr_value_same(&is.s, &i))
|
|
|
|
goto cleanup;
|
|
|
|
if (!bs.s.not_found && ext4_xattr_value_same(&bs.s, &i))
|
|
|
|
goto cleanup;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_ibody_set(handle, inode, &i, &is);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!error && !bs.s.not_found) {
|
|
|
|
i.value = NULL;
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_block_set(handle, inode, &i, &bs);
|
2006-10-11 15:20:50 +07:00
|
|
|
} else if (error == -ENOSPC) {
|
2008-05-15 06:05:47 +07:00
|
|
|
if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
|
|
|
|
error = ext4_xattr_block_find(inode, &i, &bs);
|
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_block_set(handle, inode, &i, &bs);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
if (!is.s.not_found) {
|
|
|
|
i.value = NULL;
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_ibody_set(handle, inode, &i,
|
2006-10-11 15:20:50 +07:00
|
|
|
&is);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!error) {
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_update_super_block(handle, inode->i_sb);
|
2007-07-18 20:15:20 +07:00
|
|
|
inode->i_ctime = ext4_current_time(inode);
|
2007-07-18 20:19:57 +07:00
|
|
|
if (!value)
|
2010-01-25 02:34:07 +07:00
|
|
|
ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* The bh is consumed by ext4_mark_iloc_dirty, even with
|
2006-10-11 15:20:50 +07:00
|
|
|
* error != 0.
|
|
|
|
*/
|
|
|
|
is.iloc.bh = NULL;
|
|
|
|
if (IS_SYNC(inode))
|
2009-01-07 12:06:22 +07:00
|
|
|
ext4_handle_sync(handle);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
brelse(is.iloc.bh);
|
|
|
|
brelse(bs.bh);
|
2008-10-09 10:21:54 +07:00
|
|
|
if (no_expand == 0)
|
2010-01-25 02:34:07 +07:00
|
|
|
ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
|
2006-10-11 15:20:53 +07:00
|
|
|
up_write(&EXT4_I(inode)->xattr_sem);
|
2006-10-11 15:20:50 +07:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_xattr_set()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
2006-10-11 15:20:53 +07:00
|
|
|
* Like ext4_xattr_set_handle, but start from an inode. This extended
|
2006-10-11 15:20:50 +07:00
|
|
|
* attribute modification is a filesystem transaction by itself.
|
|
|
|
*
|
|
|
|
* Returns 0, or a negative error number on failure.
|
|
|
|
*/
|
|
|
|
int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_set(struct inode *inode, int name_index, const char *name,
|
2006-10-11 15:20:50 +07:00
|
|
|
const void *value, size_t value_len, int flags)
|
|
|
|
{
|
|
|
|
handle_t *handle;
|
|
|
|
int error, retries = 0;
|
2013-02-10 03:23:03 +07:00
|
|
|
int credits = ext4_jbd2_credits_xattr(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
retry:
|
2013-02-09 09:59:22 +07:00
|
|
|
handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (IS_ERR(handle)) {
|
|
|
|
error = PTR_ERR(handle);
|
|
|
|
} else {
|
|
|
|
int error2;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
error = ext4_xattr_set_handle(handle, inode, name_index, name,
|
2006-10-11 15:20:50 +07:00
|
|
|
value, value_len, flags);
|
2006-10-11 15:20:53 +07:00
|
|
|
error2 = ext4_journal_stop(handle);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error == -ENOSPC &&
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_should_retry_alloc(inode->i_sb, &retries))
|
2006-10-11 15:20:50 +07:00
|
|
|
goto retry;
|
|
|
|
if (error == 0)
|
|
|
|
error = error2;
|
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-07-18 20:19:57 +07:00
|
|
|
/*
|
|
|
|
* Shift the EA entries in the inode to create space for the increased
|
|
|
|
* i_extra_isize.
|
|
|
|
*/
|
|
|
|
static void ext4_xattr_shift_entries(struct ext4_xattr_entry *entry,
|
|
|
|
int value_offs_shift, void *to,
|
|
|
|
void *from, size_t n, int blocksize)
|
|
|
|
{
|
|
|
|
struct ext4_xattr_entry *last = entry;
|
|
|
|
int new_offs;
|
|
|
|
|
|
|
|
/* Adjust the value offsets of the entries */
|
|
|
|
for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
|
|
|
|
if (!last->e_value_block && last->e_value_size) {
|
|
|
|
new_offs = le16_to_cpu(last->e_value_offs) +
|
|
|
|
value_offs_shift;
|
|
|
|
BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
|
|
|
|
> blocksize);
|
|
|
|
last->e_value_offs = cpu_to_le16(new_offs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Shift the entries by n bytes */
|
|
|
|
memmove(to, from, n);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Expand an inode by new_extra_isize bytes when EAs are present.
|
|
|
|
* Returns 0 on success or negative error number on failure.
|
|
|
|
*/
|
|
|
|
int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
|
|
|
|
struct ext4_inode *raw_inode, handle_t *handle)
|
|
|
|
{
|
|
|
|
struct ext4_xattr_ibody_header *header;
|
|
|
|
struct ext4_xattr_entry *entry, *last, *first;
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
struct ext4_xattr_ibody_find *is = NULL;
|
|
|
|
struct ext4_xattr_block_find *bs = NULL;
|
|
|
|
char *buffer = NULL, *b_entry_name = NULL;
|
|
|
|
size_t min_offs, free;
|
2014-02-20 08:15:21 +07:00
|
|
|
int total_ino;
|
2007-07-18 20:19:57 +07:00
|
|
|
void *base, *start, *end;
|
|
|
|
int extra_isize = 0, error = 0, tried_min_extra_isize = 0;
|
2007-10-17 05:38:25 +07:00
|
|
|
int s_min_extra_isize = le16_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_min_extra_isize);
|
2007-07-18 20:19:57 +07:00
|
|
|
|
|
|
|
down_write(&EXT4_I(inode)->xattr_sem);
|
|
|
|
retry:
|
|
|
|
if (EXT4_I(inode)->i_extra_isize >= new_extra_isize) {
|
|
|
|
up_write(&EXT4_I(inode)->xattr_sem);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
header = IHDR(inode, raw_inode);
|
|
|
|
entry = IFIRST(header);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if enough free space is available in the inode to shift the
|
|
|
|
* entries ahead by new_extra_isize.
|
|
|
|
*/
|
|
|
|
|
|
|
|
base = start = entry;
|
|
|
|
end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
|
|
|
|
min_offs = end - base;
|
|
|
|
last = entry;
|
|
|
|
total_ino = sizeof(struct ext4_xattr_ibody_header);
|
|
|
|
|
|
|
|
free = ext4_xattr_free_space(last, &min_offs, base, &total_ino);
|
|
|
|
if (free >= new_extra_isize) {
|
|
|
|
entry = IFIRST(header);
|
|
|
|
ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize
|
|
|
|
- new_extra_isize, (void *)raw_inode +
|
|
|
|
EXT4_GOOD_OLD_INODE_SIZE + new_extra_isize,
|
|
|
|
(void *)header, total_ino,
|
|
|
|
inode->i_sb->s_blocksize);
|
|
|
|
EXT4_I(inode)->i_extra_isize = new_extra_isize;
|
|
|
|
error = 0;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Enough free space isn't available in the inode, check if
|
|
|
|
* EA block can hold new_extra_isize bytes.
|
|
|
|
*/
|
|
|
|
if (EXT4_I(inode)->i_file_acl) {
|
|
|
|
bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
|
|
|
|
error = -EIO;
|
|
|
|
if (!bh)
|
|
|
|
goto cleanup;
|
2012-04-30 05:43:10 +07:00
|
|
|
if (ext4_xattr_check_block(inode, bh)) {
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(inode, "bad block %llu",
|
|
|
|
EXT4_I(inode)->i_file_acl);
|
2015-10-18 03:16:04 +07:00
|
|
|
error = -EFSCORRUPTED;
|
2007-07-18 20:19:57 +07:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
base = BHDR(bh);
|
|
|
|
first = BFIRST(bh);
|
|
|
|
end = bh->b_data + bh->b_size;
|
|
|
|
min_offs = end - base;
|
2014-02-20 08:15:21 +07:00
|
|
|
free = ext4_xattr_free_space(first, &min_offs, base, NULL);
|
2007-07-18 20:19:57 +07:00
|
|
|
if (free < new_extra_isize) {
|
|
|
|
if (!tried_min_extra_isize && s_min_extra_isize) {
|
|
|
|
tried_min_extra_isize++;
|
|
|
|
new_extra_isize = s_min_extra_isize;
|
|
|
|
brelse(bh);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
error = -1;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
free = inode->i_sb->s_blocksize;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (new_extra_isize > 0) {
|
|
|
|
size_t offs, size, entry_size;
|
|
|
|
struct ext4_xattr_entry *small_entry = NULL;
|
|
|
|
struct ext4_xattr_info i = {
|
|
|
|
.value = NULL,
|
|
|
|
.value_len = 0,
|
|
|
|
};
|
|
|
|
unsigned int total_size; /* EA entry size + value size */
|
|
|
|
unsigned int shift_bytes; /* No. of bytes to shift EAs by? */
|
|
|
|
unsigned int min_total_size = ~0U;
|
|
|
|
|
|
|
|
is = kzalloc(sizeof(struct ext4_xattr_ibody_find), GFP_NOFS);
|
|
|
|
bs = kzalloc(sizeof(struct ext4_xattr_block_find), GFP_NOFS);
|
|
|
|
if (!is || !bs) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
is->s.not_found = -ENODATA;
|
|
|
|
bs->s.not_found = -ENODATA;
|
|
|
|
is->iloc.bh = NULL;
|
|
|
|
bs->bh = NULL;
|
|
|
|
|
|
|
|
last = IFIRST(header);
|
|
|
|
/* Find the entry best suited to be pushed into EA block */
|
|
|
|
entry = NULL;
|
|
|
|
for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
|
|
|
|
total_size =
|
|
|
|
EXT4_XATTR_SIZE(le32_to_cpu(last->e_value_size)) +
|
|
|
|
EXT4_XATTR_LEN(last->e_name_len);
|
|
|
|
if (total_size <= free && total_size < min_total_size) {
|
|
|
|
if (total_size < new_extra_isize) {
|
|
|
|
small_entry = last;
|
|
|
|
} else {
|
|
|
|
entry = last;
|
|
|
|
min_total_size = total_size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (entry == NULL) {
|
|
|
|
if (small_entry) {
|
|
|
|
entry = small_entry;
|
|
|
|
} else {
|
|
|
|
if (!tried_min_extra_isize &&
|
|
|
|
s_min_extra_isize) {
|
|
|
|
tried_min_extra_isize++;
|
|
|
|
new_extra_isize = s_min_extra_isize;
|
2013-10-11 07:05:35 +07:00
|
|
|
kfree(is); is = NULL;
|
|
|
|
kfree(bs); bs = NULL;
|
2013-11-01 10:00:24 +07:00
|
|
|
brelse(bh);
|
2007-07-18 20:19:57 +07:00
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
error = -1;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
offs = le16_to_cpu(entry->e_value_offs);
|
|
|
|
size = le32_to_cpu(entry->e_value_size);
|
|
|
|
entry_size = EXT4_XATTR_LEN(entry->e_name_len);
|
|
|
|
i.name_index = entry->e_name_index,
|
|
|
|
buffer = kmalloc(EXT4_XATTR_SIZE(size), GFP_NOFS);
|
|
|
|
b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);
|
|
|
|
if (!buffer || !b_entry_name) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
/* Save the entry name and the entry value */
|
|
|
|
memcpy(buffer, (void *)IFIRST(header) + offs,
|
|
|
|
EXT4_XATTR_SIZE(size));
|
|
|
|
memcpy(b_entry_name, entry->e_name, entry->e_name_len);
|
|
|
|
b_entry_name[entry->e_name_len] = '\0';
|
|
|
|
i.name = b_entry_name;
|
|
|
|
|
|
|
|
error = ext4_get_inode_loc(inode, &is->iloc);
|
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
error = ext4_xattr_ibody_find(inode, &i, is);
|
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
/* Remove the chosen entry from the inode */
|
|
|
|
error = ext4_xattr_ibody_set(handle, inode, &i, is);
|
2010-02-16 02:26:16 +07:00
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
2007-07-18 20:19:57 +07:00
|
|
|
|
|
|
|
entry = IFIRST(header);
|
|
|
|
if (entry_size + EXT4_XATTR_SIZE(size) >= new_extra_isize)
|
|
|
|
shift_bytes = new_extra_isize;
|
|
|
|
else
|
|
|
|
shift_bytes = entry_size + size;
|
|
|
|
/* Adjust the offsets and shift the remaining entries ahead */
|
|
|
|
ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize -
|
|
|
|
shift_bytes, (void *)raw_inode +
|
|
|
|
EXT4_GOOD_OLD_INODE_SIZE + extra_isize + shift_bytes,
|
|
|
|
(void *)header, total_ino - entry_size,
|
|
|
|
inode->i_sb->s_blocksize);
|
|
|
|
|
|
|
|
extra_isize += shift_bytes;
|
|
|
|
new_extra_isize -= shift_bytes;
|
|
|
|
EXT4_I(inode)->i_extra_isize = extra_isize;
|
|
|
|
|
|
|
|
i.name = b_entry_name;
|
|
|
|
i.value = buffer;
|
2007-10-17 05:38:25 +07:00
|
|
|
i.value_len = size;
|
2007-07-18 20:19:57 +07:00
|
|
|
error = ext4_xattr_block_find(inode, &i, bs);
|
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
/* Add entry which was removed from the inode into the block */
|
|
|
|
error = ext4_xattr_block_set(handle, inode, &i, bs);
|
|
|
|
if (error)
|
|
|
|
goto cleanup;
|
|
|
|
kfree(b_entry_name);
|
|
|
|
kfree(buffer);
|
2009-12-23 19:52:31 +07:00
|
|
|
b_entry_name = NULL;
|
|
|
|
buffer = NULL;
|
2007-07-18 20:19:57 +07:00
|
|
|
brelse(is->iloc.bh);
|
|
|
|
kfree(is);
|
|
|
|
kfree(bs);
|
|
|
|
}
|
|
|
|
brelse(bh);
|
|
|
|
up_write(&EXT4_I(inode)->xattr_sem);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
kfree(b_entry_name);
|
|
|
|
kfree(buffer);
|
|
|
|
if (is)
|
|
|
|
brelse(is->iloc.bh);
|
|
|
|
kfree(is);
|
|
|
|
kfree(bs);
|
|
|
|
brelse(bh);
|
|
|
|
up_write(&EXT4_I(inode)->xattr_sem);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-10-11 15:20:50 +07:00
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_xattr_delete_inode()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* Free extended attribute resources associated with this inode. This
|
|
|
|
* is called immediately before an inode is freed. We have exclusive
|
|
|
|
* access to the inode.
|
|
|
|
*/
|
|
|
|
void
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_delete_inode(handle_t *handle, struct inode *inode)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
if (!EXT4_I(inode)->i_file_acl)
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
2006-10-11 15:20:53 +07:00
|
|
|
bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (!bh) {
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(inode, "block %llu read error",
|
|
|
|
EXT4_I(inode)->i_file_acl);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
|
2006-10-11 15:20:50 +07:00
|
|
|
BHDR(bh)->h_blocks != cpu_to_le32(1)) {
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(inode, "bad block %llu",
|
|
|
|
EXT4_I(inode)->i_file_acl);
|
2006-10-11 15:20:50 +07:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_release_block(handle, inode, bh);
|
|
|
|
EXT4_I(inode)->i_file_acl = 0;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
brelse(bh);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_xattr_cache_insert()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* Create a new entry in the extended attribute cache, and insert
|
|
|
|
* it unless such an entry is already in the cache.
|
|
|
|
*
|
|
|
|
* Returns 0, or a negative error number on failure.
|
|
|
|
*/
|
|
|
|
static void
|
2016-02-23 10:35:22 +07:00
|
|
|
ext4_xattr_cache_insert(struct mb_cache *ext4_mb_cache, struct buffer_head *bh)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2016-02-23 10:44:04 +07:00
|
|
|
struct ext4_xattr_header *header = BHDR(bh);
|
|
|
|
__u32 hash = le32_to_cpu(header->h_hash);
|
|
|
|
int reusable = le32_to_cpu(header->h_refcount) <
|
|
|
|
EXT4_XATTR_REFCOUNT_MAX;
|
2006-10-11 15:20:50 +07:00
|
|
|
int error;
|
|
|
|
|
2016-02-23 10:35:22 +07:00
|
|
|
error = mb_cache_entry_create(ext4_mb_cache, GFP_NOFS, hash,
|
2016-02-23 10:44:04 +07:00
|
|
|
bh->b_blocknr, reusable);
|
2006-10-11 15:20:50 +07:00
|
|
|
if (error) {
|
2016-02-22 23:50:13 +07:00
|
|
|
if (error == -EBUSY)
|
2006-10-11 15:20:50 +07:00
|
|
|
ea_bdebug(bh, "already in cache");
|
2016-02-22 23:50:13 +07:00
|
|
|
} else
|
2006-10-11 15:20:50 +07:00
|
|
|
ea_bdebug(bh, "inserting [%x]", (int)hash);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_xattr_cmp()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* Compare two extended attribute blocks for equality.
|
|
|
|
*
|
|
|
|
* Returns 0 if the blocks are equal, 1 if they differ, and
|
|
|
|
* a negative error number on errors.
|
|
|
|
*/
|
|
|
|
static int
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_cmp(struct ext4_xattr_header *header1,
|
|
|
|
struct ext4_xattr_header *header2)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_entry *entry1, *entry2;
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
entry1 = ENTRY(header1+1);
|
|
|
|
entry2 = ENTRY(header2+1);
|
|
|
|
while (!IS_LAST_ENTRY(entry1)) {
|
|
|
|
if (IS_LAST_ENTRY(entry2))
|
|
|
|
return 1;
|
|
|
|
if (entry1->e_hash != entry2->e_hash ||
|
|
|
|
entry1->e_name_index != entry2->e_name_index ||
|
|
|
|
entry1->e_name_len != entry2->e_name_len ||
|
|
|
|
entry1->e_value_size != entry2->e_value_size ||
|
|
|
|
memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
|
|
|
|
return 1;
|
|
|
|
if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
|
2015-10-18 03:16:04 +07:00
|
|
|
return -EFSCORRUPTED;
|
2006-10-11 15:20:50 +07:00
|
|
|
if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
|
|
|
|
(char *)header2 + le16_to_cpu(entry2->e_value_offs),
|
|
|
|
le32_to_cpu(entry1->e_value_size)))
|
|
|
|
return 1;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
entry1 = EXT4_XATTR_NEXT(entry1);
|
|
|
|
entry2 = EXT4_XATTR_NEXT(entry2);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
if (!IS_LAST_ENTRY(entry2))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_xattr_cache_find()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* Find an identical extended attribute block.
|
|
|
|
*
|
|
|
|
* Returns a pointer to the block found, or NULL if such a block was
|
|
|
|
* not found or an error occurred.
|
|
|
|
*/
|
|
|
|
static struct buffer_head *
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_cache_find(struct inode *inode, struct ext4_xattr_header *header,
|
2016-02-23 10:35:22 +07:00
|
|
|
struct mb_cache_entry **pce)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
__u32 hash = le32_to_cpu(header->h_hash);
|
2016-02-23 10:35:22 +07:00
|
|
|
struct mb_cache_entry *ce;
|
|
|
|
struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
|
2006-10-11 15:20:50 +07:00
|
|
|
|
|
|
|
if (!header->h_hash)
|
|
|
|
return NULL; /* never share */
|
|
|
|
ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
|
2016-02-23 10:35:22 +07:00
|
|
|
ce = mb_cache_entry_find_first(ext4_mb_cache, hash);
|
2006-10-11 15:20:50 +07:00
|
|
|
while (ce) {
|
|
|
|
struct buffer_head *bh;
|
|
|
|
|
|
|
|
bh = sb_bread(inode->i_sb, ce->e_block);
|
|
|
|
if (!bh) {
|
2010-05-17 08:00:00 +07:00
|
|
|
EXT4_ERROR_INODE(inode, "block %lu read error",
|
|
|
|
(unsigned long) ce->e_block);
|
2006-10-11 15:20:53 +07:00
|
|
|
} else if (ext4_xattr_cmp(header, BHDR(bh)) == 0) {
|
2006-10-11 15:20:50 +07:00
|
|
|
*pce = ce;
|
|
|
|
return bh;
|
|
|
|
}
|
|
|
|
brelse(bh);
|
2016-02-23 10:35:22 +07:00
|
|
|
ce = mb_cache_entry_find_next(ext4_mb_cache, ce);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define NAME_HASH_SHIFT 5
|
|
|
|
#define VALUE_HASH_SHIFT 16
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_xattr_hash_entry()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* Compute the hash of an extended attribute.
|
|
|
|
*/
|
2006-10-11 15:20:53 +07:00
|
|
|
static inline void ext4_xattr_hash_entry(struct ext4_xattr_header *header,
|
|
|
|
struct ext4_xattr_entry *entry)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
|
|
|
__u32 hash = 0;
|
|
|
|
char *name = entry->e_name;
|
|
|
|
int n;
|
|
|
|
|
2008-07-27 03:15:44 +07:00
|
|
|
for (n = 0; n < entry->e_name_len; n++) {
|
2006-10-11 15:20:50 +07:00
|
|
|
hash = (hash << NAME_HASH_SHIFT) ^
|
|
|
|
(hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
|
|
|
|
*name++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (entry->e_value_block == 0 && entry->e_value_size != 0) {
|
|
|
|
__le32 *value = (__le32 *)((char *)header +
|
|
|
|
le16_to_cpu(entry->e_value_offs));
|
|
|
|
for (n = (le32_to_cpu(entry->e_value_size) +
|
2006-10-11 15:20:53 +07:00
|
|
|
EXT4_XATTR_ROUND) >> EXT4_XATTR_PAD_BITS; n; n--) {
|
2006-10-11 15:20:50 +07:00
|
|
|
hash = (hash << VALUE_HASH_SHIFT) ^
|
|
|
|
(hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
|
|
|
|
le32_to_cpu(*value++);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
entry->e_hash = cpu_to_le32(hash);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NAME_HASH_SHIFT
|
|
|
|
#undef VALUE_HASH_SHIFT
|
|
|
|
|
|
|
|
#define BLOCK_HASH_SHIFT 16
|
|
|
|
|
|
|
|
/*
|
2006-10-11 15:20:53 +07:00
|
|
|
* ext4_xattr_rehash()
|
2006-10-11 15:20:50 +07:00
|
|
|
*
|
|
|
|
* Re-compute the extended attribute hash value after an entry has changed.
|
|
|
|
*/
|
2006-10-11 15:20:53 +07:00
|
|
|
static void ext4_xattr_rehash(struct ext4_xattr_header *header,
|
|
|
|
struct ext4_xattr_entry *entry)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2006-10-11 15:20:53 +07:00
|
|
|
struct ext4_xattr_entry *here;
|
2006-10-11 15:20:50 +07:00
|
|
|
__u32 hash = 0;
|
|
|
|
|
2006-10-11 15:20:53 +07:00
|
|
|
ext4_xattr_hash_entry(header, entry);
|
2006-10-11 15:20:50 +07:00
|
|
|
here = ENTRY(header+1);
|
|
|
|
while (!IS_LAST_ENTRY(here)) {
|
|
|
|
if (!here->e_hash) {
|
|
|
|
/* Block is not shared if an entry's hash value == 0 */
|
|
|
|
hash = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
hash = (hash << BLOCK_HASH_SHIFT) ^
|
|
|
|
(hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
|
|
|
|
le32_to_cpu(here->e_hash);
|
2006-10-11 15:20:53 +07:00
|
|
|
here = EXT4_XATTR_NEXT(here);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
header->h_hash = cpu_to_le32(hash);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef BLOCK_HASH_SHIFT
|
|
|
|
|
2014-03-19 06:24:49 +07:00
|
|
|
#define HASH_BUCKET_BITS 10
|
|
|
|
|
2016-02-23 10:35:22 +07:00
|
|
|
struct mb_cache *
|
2016-02-22 23:50:13 +07:00
|
|
|
ext4_xattr_create_cache(void)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2016-02-23 10:35:22 +07:00
|
|
|
return mb_cache_create(HASH_BUCKET_BITS);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
|
|
|
|
2016-02-23 10:35:22 +07:00
|
|
|
void ext4_xattr_destroy_cache(struct mb_cache *cache)
|
2006-10-11 15:20:50 +07:00
|
|
|
{
|
2014-03-19 06:24:49 +07:00
|
|
|
if (cache)
|
2016-02-23 10:35:22 +07:00
|
|
|
mb_cache_destroy(cache);
|
2006-10-11 15:20:50 +07:00
|
|
|
}
|
2014-03-19 06:24:49 +07:00
|
|
|
|