ext4_xattr.c File Reference

#include <ext2fs.h>
#include <linux/module.h>
#include <linux/ext4_xattr.h>

Include dependency graph for ext4_xattr.c:

Go to the source code of this file.

Classes
struct	xattr_prefix

Macros
#define	NAME_HASH_SHIFT   5
#define	VALUE_HASH_SHIFT   16
#define	BLOCK_HASH_SHIFT   16
#define	ext4_xattr_block_checksum(...)   0

Functions
static ext4_fsblk_t	ext4_new_meta_blocks (void *icb, struct inode *inode, ext4_fsblk_t goal, unsigned int flags, unsigned long *count, int *errp)
static void	ext4_free_blocks (void *icb, struct inode *inode, ext4_fsblk_t block, int count, int flags)
static ext4_fsblk_t	ext4_inode_to_goal_block (struct inode *inode)
static void	ext4_xattr_compute_hash (struct ext4_xattr_header *header, struct ext4_xattr_entry *entry)
static void	ext4_xattr_rehash (struct ext4_xattr_header *header, struct ext4_xattr_entry *entry)
static void	ext4_xattr_set_block_checksum (PEXT2_MCB inode_ref, ext4_fsblk_t blocknr, struct ext4_xattr_header *header)
static int	ext4_xattr_item_cmp (struct rb_node *_a, struct rb_node *_b)
static struct ext4_xattr_item *	ext4_xattr_item_search (struct ext4_xattr_ref *xattr_ref, struct ext4_xattr_item *name)
static void	ext4_xattr_item_insert (struct ext4_xattr_ref *xattr_ref, struct ext4_xattr_item *item)
static void	ext4_xattr_item_remove (struct ext4_xattr_ref *xattr_ref, struct ext4_xattr_item *item)
static struct ext4_xattr_item *	ext4_xattr_item_alloc (__u8 name_index, const char *name, size_t name_len)
static int	ext4_xattr_item_alloc_data (struct ext4_xattr_item *item, const void *orig_data, size_t data_size)
static void	ext4_xattr_item_free_data (struct ext4_xattr_item *item)
static int	ext4_xattr_item_resize_data (struct ext4_xattr_item *item, size_t new_data_size)
static void	ext4_xattr_item_free (struct ext4_xattr_item *item)
static void *	ext4_xattr_entry_data (struct ext4_xattr_ref *xattr_ref, struct ext4_xattr_entry *entry, BOOL in_inode)
static int	ext4_xattr_block_fetch (struct ext4_xattr_ref *xattr_ref)
static int	ext4_xattr_inode_fetch (struct ext4_xattr_ref *xattr_ref)
static __s32	ext4_xattr_inode_space (struct ext4_xattr_ref *xattr_ref)
static __s32	ext4_xattr_block_space (struct ext4_xattr_ref *xattr_ref)
static int	ext4_xattr_fetch (struct ext4_xattr_ref *xattr_ref)
static struct ext4_xattr_item *	ext4_xattr_lookup_item (struct ext4_xattr_ref *xattr_ref, __u8 name_index, const char *name, size_t name_len)
static struct ext4_xattr_item *	ext4_xattr_insert_item (struct ext4_xattr_ref *xattr_ref, __u8 name_index, const char *name, size_t name_len, const void *data, size_t data_size, int *err)
static struct ext4_xattr_item *	ext4_xattr_insert_item_ordered (struct ext4_xattr_ref *xattr_ref, __u8 name_index, const char *name, size_t name_len, const void *data, size_t data_size, int *err)
static int	ext4_xattr_remove_item (struct ext4_xattr_ref *xattr_ref, __u8 name_index, const char *name, size_t name_len)
static int	ext4_xattr_resize_item (struct ext4_xattr_ref *xattr_ref, struct ext4_xattr_item *item, size_t new_data_size)
void	ext4_xattr_purge_items (struct ext4_xattr_ref *xattr_ref)
static int	ext4_xattr_try_alloc_block (struct ext4_xattr_ref *xattr_ref)
static void	ext4_xattr_try_free_block (struct ext4_xattr_ref *xattr_ref)
static void	ext4_xattr_set_block_header (struct ext4_xattr_ref *xattr_ref)
static void	ext4_xattr_set_inode_entry (struct ext4_xattr_item *item, struct ext4_xattr_ibody_header *ibody_header, struct ext4_xattr_entry *entry, void *ibody_data_ptr)
static void	ext4_xattr_set_block_entry (struct ext4_xattr_item *item, struct ext4_xattr_header *block_header, struct ext4_xattr_entry *block_entry, void *block_data_ptr)
static int	ext4_xattr_write_to_disk (struct ext4_xattr_ref *xattr_ref)
void	ext4_fs_xattr_iterate (struct ext4_xattr_ref *ref, int(*iter)(struct ext4_xattr_ref *ref, struct ext4_xattr_item *item, BOOL is_last))
void	ext4_fs_xattr_iterate_reset (struct ext4_xattr_ref *ref)
int	ext4_fs_set_xattr (struct ext4_xattr_ref *ref, __u8 name_index, const char *name, size_t name_len, const void *data, size_t data_size, BOOL replace)
int	ext4_fs_set_xattr_ordered (struct ext4_xattr_ref *ref, __u8 name_index, const char *name, size_t name_len, const void *data, size_t data_size)
int	ext4_fs_remove_xattr (struct ext4_xattr_ref *ref, __u8 name_index, const char *name, size_t name_len)
int	ext4_fs_get_xattr (struct ext4_xattr_ref *ref, __u8 name_index, const char *name, size_t name_len, void *buf, size_t buf_size, size_t *data_size)
int	ext4_fs_get_xattr_ref (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB fs, PEXT2_MCB inode_ref, struct ext4_xattr_ref *ref)
int	ext4_fs_put_xattr_ref (struct ext4_xattr_ref *ref)
const char *	ext4_extract_xattr_name (const char *full_name, size_t full_name_len, __u8 *name_index, size_t *name_len, BOOL *found)
const char *	ext4_get_xattr_name_prefix (__u8 name_index, size_t *ret_prefix_len)

Variables
static const struct xattr_prefix	prefix_tbl []

Macro Definition Documentation

BLOCK_HASH_SHIFT

#define BLOCK_HASH_SHIFT   16

Definition at line 89 of file ext4_xattr.c.

ext4_xattr_block_checksum

#define ext4_xattr_block_checksum

(

...

)

0

Definition at line 149 of file ext4_xattr.c.

NAME_HASH_SHIFT

#define NAME_HASH_SHIFT   5

Definition at line 60 of file ext4_xattr.c.

VALUE_HASH_SHIFT

#define VALUE_HASH_SHIFT   16

Definition at line 61 of file ext4_xattr.c.

Function Documentation

ext4_free_blocks()

static void ext4_free_blocks ( void *  icb, struct inode *  inode, ext4_fsblk_t  block, int  count, int  flags  )

static

Definition at line 45 of file ext4_xattr.c.

{
    Ext2FreeBlock((PEXT2_IRP_CONTEXT)icb, inode->i_sb->s_priv, (ULONG)block, count);
    inode->i_blocks -= count * (inode->i_sb->s_blocksize >> 9);
    return;
}

Referenced by ext4_xattr_try_alloc_block(), and ext4_xattr_try_free_block().

ext4_inode_to_goal_block()

static ext4_fsblk_t ext4_inode_to_goal_block ( struct inode *  inode )

inlinestatic

Definition at line 53 of file ext4_xattr.c.

{
    PEXT2_VCB Vcb;
    Vcb = inode->i_sb->s_priv;
    return (inode->i_ino - 1) / BLOCKS_PER_GROUP;
}

Referenced by ext4_xattr_try_alloc_block().

ext4_new_meta_blocks()

static ext4_fsblk_t ext4_new_meta_blocks ( void *  icb, struct inode *  inode, ext4_fsblk_t  goal, unsigned int  flags, unsigned long *  count, int *  errp  )

static

Definition at line 20 of file ext4_xattr.c.

{
    NTSTATUS status;
    ULONG blockcnt = (count) ? *count : 1;
    ULONG block = 0;

    status = Ext2NewBlock((PEXT2_IRP_CONTEXT)icb,
        inode->i_sb->s_priv,
        0, (ULONG)goal,
        &block,
        &blockcnt);
    if (count)
        *count = blockcnt;

    if (!NT_SUCCESS(status)) {
        *errp = Ext2LinuxError(status);
        return 0;
    }
    inode->i_blocks += (blockcnt * (inode->i_sb->s_blocksize >> 9));
    return block;
}

Referenced by ext4_xattr_try_alloc_block().

ext4_xattr_block_fetch()

static int ext4_xattr_block_fetch ( struct ext4_xattr_ref *  xattr_ref )

static

Definition at line 338 of file ext4_xattr.c.

{
    int ret = 0;
    size_t size_rem;
    void *data;
    struct ext4_xattr_entry *entry = NULL;

    ASSERT(xattr_ref->block_bh->b_data);
    entry = EXT4_XATTR_BFIRST(xattr_ref->block_bh);

    size_rem = xattr_ref->fs->BlockSize;
    for (; size_rem > 0 && !EXT4_XATTR_IS_LAST_ENTRY(entry);
         entry = EXT4_XATTR_NEXT(entry),
         size_rem -= EXT4_XATTR_LEN(entry->e_name_len)) {
        struct ext4_xattr_item *item;
        char *e_name = EXT4_XATTR_NAME(entry);

        data = ext4_xattr_entry_data(xattr_ref, entry, FALSE);
        if (!data) {
            ret = -EIO;
            goto Finish;
        }

        item = ext4_xattr_item_alloc(entry->e_name_index, e_name,
                         (size_t)entry->e_name_len);
        if (!item) {
            ret = -ENOMEM;
            goto Finish;
        }
        if (ext4_xattr_item_alloc_data(
            item, data, le32_to_cpu(entry->e_value_size)) != 0) {
            ext4_xattr_item_free(item);
            ret = -ENOMEM;
            goto Finish;
        }
        ext4_xattr_item_insert(xattr_ref, item);
        xattr_ref->block_size_rem -=
            EXT4_XATTR_SIZE(item->data_size) +
            EXT4_XATTR_LEN(item->name_len);
        xattr_ref->ea_size += EXT4_XATTR_SIZE(item->data_size) +
                      EXT4_XATTR_LEN(item->name_len);
    }

Finish:
    return ret;
}

Referenced by ext4_xattr_fetch().

ext4_xattr_block_space()

static __s32 ext4_xattr_block_space ( struct ext4_xattr_ref *  xattr_ref )

static

Definition at line 444 of file ext4_xattr.c.

{
    return xattr_ref->fs->BlockSize;
}

Referenced by ext4_fs_get_xattr_ref(), ext4_xattr_purge_items(), and ext4_xattr_write_to_disk().

ext4_xattr_compute_hash()

static void ext4_xattr_compute_hash ( struct ext4_xattr_header *  header, struct ext4_xattr_entry *  entry  )

inlinestatic

Definition at line 63 of file ext4_xattr.c.

{
    __u32 hash = 0;
    char *name = EXT4_XATTR_NAME(entry);
    int n;

    for (n = 0; n < entry->e_name_len; n++) {
        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) + EXT4_XATTR_ROUND) >>
             EXT4_XATTR_PAD_BITS;
             n; n--) {
            hash = (hash << VALUE_HASH_SHIFT) ^
                   (hash >> (8 * sizeof(hash) - VALUE_HASH_SHIFT)) ^
                   le32_to_cpu(*value++);
        }
    }
    entry->e_hash = cpu_to_le32(hash);
}

Referenced by ext4_xattr_rehash(), and ext4_xattr_write_to_disk().

ext4_xattr_entry_data()

static void* ext4_xattr_entry_data ( struct ext4_xattr_ref *  xattr_ref, struct ext4_xattr_entry *  entry, BOOL  in_inode  )

static

Definition at line 309 of file ext4_xattr.c.

{
    char *ret;
    int block_size;
    if (in_inode) {
        struct ext4_xattr_ibody_header *header;
        struct ext4_xattr_entry *first_entry;
        int inode_size = xattr_ref->fs->InodeSize;
        header = EXT4_XATTR_IHDR(xattr_ref->OnDiskInode);
        first_entry = EXT4_XATTR_IFIRST(header);

        ret = ((char *)first_entry + le16_to_cpu(entry->e_value_offs));
        if (ret + EXT4_XATTR_SIZE(le32_to_cpu(entry->e_value_size)) -
            (char *)xattr_ref->OnDiskInode > inode_size)
            ret = NULL;

        return ret;

    }
    block_size = xattr_ref->fs->BlockSize;
    ret = ((char *)xattr_ref->block_bh->b_data + le16_to_cpu(entry->e_value_offs));
    if (ret + EXT4_XATTR_SIZE(le32_to_cpu(entry->e_value_size)) -
            (char *)xattr_ref->block_bh->b_data > block_size)
        ret = NULL;
    return ret;
}

Referenced by ext4_xattr_block_fetch(), and ext4_xattr_inode_fetch().

ext4_xattr_fetch()

static int ext4_xattr_fetch ( struct ext4_xattr_ref *  xattr_ref )

static

Definition at line 449 of file ext4_xattr.c.

{
    int ret = 0;
    int inode_size = xattr_ref->fs->InodeSize;
    if (inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
        ret = ext4_xattr_inode_fetch(xattr_ref);
        if (ret != 0)
            return ret;
    }

    if (xattr_ref->block_loaded)
        ret = ext4_xattr_block_fetch(xattr_ref);

    xattr_ref->dirty = FALSE;
    return ret;
}

Referenced by ext4_fs_get_xattr_ref().

ext4_xattr_inode_fetch()

static int ext4_xattr_inode_fetch ( struct ext4_xattr_ref *  xattr_ref )

static

Definition at line 385 of file ext4_xattr.c.

{
    void *data;
    size_t size_rem;
    int ret = 0;
    struct ext4_xattr_ibody_header *header = NULL;
    struct ext4_xattr_entry *entry = NULL;
    int inode_size = xattr_ref->fs->InodeSize;

    header = EXT4_XATTR_IHDR(xattr_ref->OnDiskInode);
    entry = EXT4_XATTR_IFIRST(header);

    size_rem = inode_size - EXT4_GOOD_OLD_INODE_SIZE -
           xattr_ref->OnDiskInode->i_extra_isize;
    for (; size_rem > 0 && !EXT4_XATTR_IS_LAST_ENTRY(entry);
         entry = EXT4_XATTR_NEXT(entry),
         size_rem -= EXT4_XATTR_LEN(entry->e_name_len)) {
        struct ext4_xattr_item *item;
        char *e_name = EXT4_XATTR_NAME(entry);

        data = ext4_xattr_entry_data(xattr_ref, entry, TRUE);
        if (!data) {
            ret = -EIO;
            goto Finish;
        }

        item = ext4_xattr_item_alloc(entry->e_name_index, e_name,
                         (size_t)entry->e_name_len);
        if (!item) {
            ret = -ENOMEM;
            goto Finish;
        }
        if (ext4_xattr_item_alloc_data(
            item, data, le32_to_cpu(entry->e_value_size)) != 0) {
            ext4_xattr_item_free(item);
            ret = -ENOMEM;
            goto Finish;
        }
        item->in_inode = TRUE;
        ext4_xattr_item_insert(xattr_ref, item);
        xattr_ref->inode_size_rem -=
            EXT4_XATTR_SIZE(item->data_size) +
            EXT4_XATTR_LEN(item->name_len);
        xattr_ref->ea_size += EXT4_XATTR_SIZE(item->data_size) +
                      EXT4_XATTR_LEN(item->name_len);
    }

Finish:
    return ret;
}

Referenced by ext4_xattr_fetch().

ext4_xattr_inode_space()

static __s32 ext4_xattr_inode_space ( struct ext4_xattr_ref *  xattr_ref )

static

Definition at line 436 of file ext4_xattr.c.

{
    int inode_size = xattr_ref->fs->InodeSize;
    int size_rem = inode_size - EXT4_GOOD_OLD_INODE_SIZE -
                xattr_ref->OnDiskInode->i_extra_isize;
    return size_rem;
}

Referenced by ext4_fs_get_xattr_ref(), ext4_xattr_purge_items(), and ext4_xattr_write_to_disk().

ext4_xattr_insert_item()

static struct ext4_xattr_item* ext4_xattr_insert_item ( struct ext4_xattr_ref *  xattr_ref, __u8  name_index, const char *  name, size_t  name_len, const void *  data, size_t  data_size, int *  err  )

static

Definition at line 486 of file ext4_xattr.c.

{
    struct ext4_xattr_item *item;
    item = ext4_xattr_item_alloc(name_index, name, name_len);
    if (!item) {
        if (err)
            *err = -ENOMEM;

        return NULL;
    }

    item->in_inode = TRUE;
    if (xattr_ref->inode_size_rem <
       EXT4_XATTR_SIZE(data_size) +
       EXT4_XATTR_LEN(item->name_len)) {
        if (xattr_ref->block_size_rem <
           EXT4_XATTR_SIZE(data_size) +
           EXT4_XATTR_LEN(item->name_len)) {
            if (err)
                *err = -ENOSPC;

            return NULL;
        }

        item->in_inode = FALSE;
    }
    if (ext4_xattr_item_alloc_data(item, data, data_size) != 0) {
        ext4_xattr_item_free(item);
        if (err)
            *err = -ENOMEM;

        return NULL;
    }
    ext4_xattr_item_insert(xattr_ref, item);
    xattr_ref->ea_size +=
        EXT4_XATTR_SIZE(item->data_size) + EXT4_XATTR_LEN(item->name_len);
    if (item->in_inode) {
        xattr_ref->inode_size_rem -=
            EXT4_XATTR_SIZE(item->data_size) +
            EXT4_XATTR_LEN(item->name_len);
    } else {
        xattr_ref->block_size_rem -=
            EXT4_XATTR_SIZE(item->data_size) +
            EXT4_XATTR_LEN(item->name_len);
    }
    xattr_ref->dirty = TRUE;
    if (err)
        *err = 0;

    return item;
}

Referenced by ext4_fs_set_xattr().

ext4_xattr_insert_item_ordered()

static struct ext4_xattr_item* ext4_xattr_insert_item_ordered ( struct ext4_xattr_ref *  xattr_ref, __u8  name_index, const char *  name, size_t  name_len, const void *  data, size_t  data_size, int *  err  )

static

Definition at line 542 of file ext4_xattr.c.

{
    struct ext4_xattr_item *item, *last_item = NULL;
    item = ext4_xattr_item_alloc(name_index, name, name_len);
    if (!item) {
        if (err)
            *err = -ENOMEM;

        return NULL;
    }

    if (!list_empty(&xattr_ref->ordered_list))
        last_item = list_entry(xattr_ref->ordered_list.prev,
                    struct ext4_xattr_item,
                    list_node);

    item->in_inode = TRUE;
    if ((xattr_ref->inode_size_rem <
        EXT4_XATTR_SIZE(data_size) +
        EXT4_XATTR_LEN(item->name_len))
            ||
        (last_item && !last_item->in_inode)) {
        if (xattr_ref->block_size_rem <
            EXT4_XATTR_SIZE(data_size) +
            EXT4_XATTR_LEN(item->name_len)) {
            if (err)
                *err = -ENOSPC;

            return NULL;
        }

        item->in_inode = FALSE;
    }
    if (ext4_xattr_item_alloc_data(item, data, data_size) != 0) {
        ext4_xattr_item_free(item);
        if (err)
            *err = -ENOMEM;

        return NULL;
    }
    ext4_xattr_item_insert(xattr_ref, item);
    xattr_ref->ea_size +=
        EXT4_XATTR_SIZE(item->data_size) + EXT4_XATTR_LEN(item->name_len);
    if (item->in_inode) {
        xattr_ref->inode_size_rem -=
            EXT4_XATTR_SIZE(item->data_size) +
            EXT4_XATTR_LEN(item->name_len);
    }
    else {
        xattr_ref->block_size_rem -=
            EXT4_XATTR_SIZE(item->data_size) +
            EXT4_XATTR_LEN(item->name_len);
    }
    xattr_ref->dirty = TRUE;
    if (err)
        *err = 0;

    return item;
}

Referenced by ext4_fs_set_xattr_ordered().

ext4_xattr_item_alloc()

static struct ext4_xattr_item* ext4_xattr_item_alloc ( __u8  name_index, const char *  name, size_t  name_len  )

static

Definition at line 232 of file ext4_xattr.c.

{
    struct ext4_xattr_item *item;
    item = kzalloc(sizeof(struct ext4_xattr_item) + name_len, GFP_NOFS);
    if (!item)
        return NULL;

    item->name_index = name_index;
    item->name = (char *)(item + 1);
    item->name_len = name_len;
    item->data = NULL;
    item->data_size = 0;
    INIT_LIST_HEAD(&item->list_node);

    memcpy(item->name, name, name_len);

    if (name_index == EXT4_XATTR_INDEX_SYSTEM &&
        name_len == 4 &&
        !memcmp(name, "data", 4))
        item->is_data = TRUE;
    else
        item->is_data = FALSE;

    return item;
}

Referenced by ext4_xattr_block_fetch(), ext4_xattr_inode_fetch(), ext4_xattr_insert_item(), and ext4_xattr_insert_item_ordered().

ext4_xattr_item_alloc_data()

static int ext4_xattr_item_alloc_data ( struct ext4_xattr_item *  item, const void *  orig_data, size_t  data_size  )

static

Definition at line 258 of file ext4_xattr.c.

{
    void *data = NULL;
    ASSERT(!item->data);
    data = kmalloc(data_size, GFP_NOFS);
    if (!data)
        return -ENOMEM;

    if (orig_data)
        memcpy(data, orig_data, data_size);

    item->data = data;
    item->data_size = data_size;
    return 0;
}

Referenced by ext4_xattr_block_fetch(), ext4_xattr_inode_fetch(), ext4_xattr_insert_item(), and ext4_xattr_insert_item_ordered().

ext4_xattr_item_cmp()

static int ext4_xattr_item_cmp ( struct rb_node *  _a, struct rb_node *  _b  )

static

Definition at line 161 of file ext4_xattr.c.

{
    int result;
    struct ext4_xattr_item *a, *b;
    a = container_of(_a, struct ext4_xattr_item, node);
    a = container_of(_a, struct ext4_xattr_item, node);
    b = container_of(_b, struct ext4_xattr_item, node);

    if (a->is_data && !b->is_data)
        return -1;
    
    if (!a->is_data && b->is_data)
        return 1;

    result = a->name_index - b->name_index;
    if (result)
        return result;

    if (a->name_len < b->name_len)
        return -1;

    if (a->name_len > b->name_len)
        return 1;

    return memcmp(a->name, b->name, a->name_len);
}

Referenced by ext4_xattr_item_insert(), and ext4_xattr_item_search().

ext4_xattr_item_free()

static void ext4_xattr_item_free ( struct ext4_xattr_item *  item )

static

Definition at line 301 of file ext4_xattr.c.

{
    if (item->data)
        ext4_xattr_item_free_data(item);

    kfree(item);
}

Referenced by ext4_xattr_block_fetch(), ext4_xattr_inode_fetch(), ext4_xattr_insert_item(), ext4_xattr_insert_item_ordered(), ext4_xattr_purge_items(), and ext4_xattr_remove_item().

ext4_xattr_item_free_data()

static void ext4_xattr_item_free_data ( struct ext4_xattr_item *  item )

static

Definition at line 275 of file ext4_xattr.c.

{
    ASSERT(item->data);
    kfree(item->data);
    item->data = NULL;
    item->data_size = 0;
}

Referenced by ext4_xattr_item_free().

ext4_xattr_item_insert()

static void ext4_xattr_item_insert ( struct ext4_xattr_ref *  xattr_ref, struct ext4_xattr_item *  item  )

static

Definition at line 216 of file ext4_xattr.c.

{
    rb_insert(&xattr_ref->root, &item->node,
          ext4_xattr_item_cmp);
    list_add_tail(&item->list_node, &xattr_ref->ordered_list);
}

Referenced by ext4_xattr_block_fetch(), ext4_xattr_inode_fetch(), ext4_xattr_insert_item(), and ext4_xattr_insert_item_ordered().

ext4_xattr_item_remove()

static void ext4_xattr_item_remove ( struct ext4_xattr_ref *  xattr_ref, struct ext4_xattr_item *  item  )

static

Definition at line 224 of file ext4_xattr.c.

{
    rb_erase(&item->node, &xattr_ref->root);
    list_del_init(&item->list_node);
}

Referenced by ext4_xattr_purge_items(), and ext4_xattr_remove_item().

ext4_xattr_item_resize_data()

static int ext4_xattr_item_resize_data ( struct ext4_xattr_item *  item, size_t  new_data_size  )

static

Definition at line 283 of file ext4_xattr.c.

{
    if (new_data_size != item->data_size) {
        void *new_data;
        new_data = kmalloc(new_data_size, GFP_NOFS);
        if (!new_data)
            return -ENOMEM;

        memcpy(new_data, item->data, item->data_size);
        kfree(item->data);

        item->data = new_data;
        item->data_size = new_data_size;
    }
    return 0;
}

Referenced by ext4_xattr_resize_item().

ext4_xattr_item_search()

static struct ext4_xattr_item* ext4_xattr_item_search ( struct ext4_xattr_ref *  xattr_ref, struct ext4_xattr_item *  name  )

static

Definition at line 194 of file ext4_xattr.c.

{
    struct rb_node *new = xattr_ref->root.rb_node;

    while (new) {
        struct ext4_xattr_item *node =
            container_of(new, struct ext4_xattr_item, node);
        int result = ext4_xattr_item_cmp(&name->node, new);

        if (result < 0)
            new = new->rb_left;
        else if (result > 0)
            new = new->rb_right;
        else
            return node;

    }

    return NULL;
}

Referenced by ext4_xattr_lookup_item().

ext4_xattr_lookup_item()

static struct ext4_xattr_item* ext4_xattr_lookup_item ( struct ext4_xattr_ref *  xattr_ref, __u8  name_index, const char *  name, size_t  name_len  )

static

Definition at line 467 of file ext4_xattr.c.

{
    struct ext4_xattr_item tmp = {
        FALSE,
        FALSE,
        name_index,
        (char *)name, /*won't touch this string*/
        name_len,
    };
    if (name_index == EXT4_XATTR_INDEX_SYSTEM &&
        name_len == 4 &&
        !memcmp(name, "data", 4))
        tmp.is_data = TRUE;

    return ext4_xattr_item_search(xattr_ref, &tmp);
}

Referenced by ext4_fs_get_xattr(), ext4_fs_set_xattr(), ext4_fs_set_xattr_ordered(), and ext4_xattr_remove_item().

ext4_xattr_rehash()

static void ext4_xattr_rehash ( struct ext4_xattr_header *  header, struct ext4_xattr_entry *  entry  )

static

Definition at line 96 of file ext4_xattr.c.

{
    struct ext4_xattr_entry *here;
    __u32 hash = 0;

    ext4_xattr_compute_hash(header, entry);
    here = EXT4_XATTR_ENTRY(header + 1);
    while (!EXT4_XATTR_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);
        here = EXT4_XATTR_NEXT(here);
    }
    header->h_hash = cpu_to_le32(hash);
}

Referenced by ext4_xattr_write_to_disk().

ext4_xattr_remove_item()

static int ext4_xattr_remove_item ( struct ext4_xattr_ref *  xattr_ref, __u8  name_index, const char *  name, size_t  name_len  )

static

Definition at line 605 of file ext4_xattr.c.

{
    int ret = -ENOENT;
    struct ext4_xattr_item *item =
        ext4_xattr_lookup_item(xattr_ref, name_index, name, name_len);
    if (item) {
        if (item == xattr_ref->iter_from) {
            struct rb_node *next_node;
            next_node = rb_next(&item->node);
            if (next_node)
                xattr_ref->iter_from =
                    container_of(next_node,
                             struct ext4_xattr_item,
                             node);
            else
                xattr_ref->iter_from = NULL;
        }

        xattr_ref->ea_size -= EXT4_XATTR_SIZE(item->data_size) +
                      EXT4_XATTR_LEN(item->name_len);

        if (item->in_inode) {
            xattr_ref->inode_size_rem +=
                EXT4_XATTR_SIZE(item->data_size) +
                EXT4_XATTR_LEN(item->name_len);
        } else {
            xattr_ref->block_size_rem +=
                EXT4_XATTR_SIZE(item->data_size) +
                EXT4_XATTR_LEN(item->name_len);
        }

        ext4_xattr_item_remove(xattr_ref, item);
        ext4_xattr_item_free(item);
        xattr_ref->dirty = TRUE;
        ret = 0;
    }
    return ret;
}

Referenced by ext4_fs_remove_xattr().

ext4_xattr_resize_item()

static int ext4_xattr_resize_item ( struct ext4_xattr_ref *  xattr_ref, struct ext4_xattr_item *  item, size_t  new_data_size  )

static

Definition at line 646 of file ext4_xattr.c.

{
    int ret = 0;
    BOOL to_inode = FALSE, to_block = FALSE;
    size_t old_data_size = item->data_size;
    size_t orig_room_size = item->in_inode ?
        xattr_ref->inode_size_rem :
        xattr_ref->block_size_rem;

    /*
     * Check if we can hold this entry in both in-inode and
     * on-block form
     *
     * More complicated case: we do not allow entries stucking in
     * the middle between in-inode space and on-block space, so
     * the entry has to stay in either inode space or block space.
     */
    if (item->in_inode) {
        if (xattr_ref->inode_size_rem +
                   EXT4_XATTR_SIZE(old_data_size) <
                   EXT4_XATTR_SIZE(new_data_size)) {
            if (xattr_ref->block_size_rem <
                       EXT4_XATTR_SIZE(new_data_size) +
                       EXT4_XATTR_LEN(item->name_len))
                return -ENOSPC;

            to_block = TRUE;
        }
    } else {
        if (xattr_ref->block_size_rem +
                EXT4_XATTR_SIZE(old_data_size) <
                EXT4_XATTR_SIZE(new_data_size)) {
            if (xattr_ref->inode_size_rem <
                    EXT4_XATTR_SIZE(new_data_size) +
                    EXT4_XATTR_LEN(item->name_len))
                return -ENOSPC;

            to_inode = TRUE;
        }
    }
    ret = ext4_xattr_item_resize_data(item, new_data_size);
    if (ret)
        return ret;

    xattr_ref->ea_size =
        xattr_ref->ea_size -
        EXT4_XATTR_SIZE(old_data_size) +
        EXT4_XATTR_SIZE(new_data_size);

    /*
     * This entry may originally lie in inode space or block space,
     * and it is going to be transferred to another place.
     */
    if (to_block) {
        xattr_ref->inode_size_rem +=
            EXT4_XATTR_SIZE(old_data_size) +
            EXT4_XATTR_LEN(item->name_len);
        xattr_ref->block_size_rem -=
            EXT4_XATTR_SIZE(new_data_size) +
            EXT4_XATTR_LEN(item->name_len);
        item->in_inode = FALSE;
    } else if (to_inode) {
        xattr_ref->block_size_rem +=
            EXT4_XATTR_SIZE(old_data_size) +
            EXT4_XATTR_LEN(item->name_len);
        xattr_ref->inode_size_rem -=
            EXT4_XATTR_SIZE(new_data_size) +
            EXT4_XATTR_LEN(item->name_len);
        item->in_inode = TRUE;
    } else {
        /*
         * No need to transfer as there is enough space for the entry
         * to stay in inode space or block space it used to be.
         */
        orig_room_size +=
            EXT4_XATTR_SIZE(old_data_size);
        orig_room_size -=
            EXT4_XATTR_SIZE(new_data_size);
        if (item->in_inode)
            xattr_ref->inode_size_rem = orig_room_size;
        else
            xattr_ref->block_size_rem = orig_room_size;

    }
    xattr_ref->dirty = TRUE;
    return ret;
}

Referenced by ext4_fs_set_xattr().

ext4_xattr_set_block_checksum()

static void ext4_xattr_set_block_checksum ( PEXT2_MCB  inode_ref, ext4_fsblk_t  blocknr, struct ext4_xattr_header *  header  )

static

Definition at line 153 of file ext4_xattr.c.

{
    /* TODO: Need METADATA_CSUM supports. */
    header->h_checksum = 0;
}

Referenced by ext4_xattr_write_to_disk().

ext4_xattr_set_block_entry()

static void ext4_xattr_set_block_entry ( struct ext4_xattr_item *  item, struct ext4_xattr_header *  block_header, struct ext4_xattr_entry *  block_entry, void *  block_data_ptr  )

static

Definition at line 845 of file ext4_xattr.c.

{
    block_entry->e_name_len = (__u8)item->name_len;
    block_entry->e_name_index = item->name_index;
    block_entry->e_value_offs =
        cpu_to_le16((char *)block_data_ptr - (char *)block_header);
    block_entry->e_value_block = 0;
    block_entry->e_value_size = cpu_to_le32(item->data_size);
}

Referenced by ext4_xattr_write_to_disk().

ext4_xattr_set_block_header()

static void ext4_xattr_set_block_header ( struct ext4_xattr_ref *  xattr_ref )

static

Definition at line 821 of file ext4_xattr.c.

{
    struct ext4_xattr_header *block_header = NULL;
    block_header = EXT4_XATTR_BHDR(xattr_ref->block_bh);

    memset(block_header, 0, sizeof(struct ext4_xattr_header));
    block_header->h_magic = EXT4_XATTR_MAGIC;
    block_header->h_refcount = cpu_to_le32(1);
    block_header->h_blocks = cpu_to_le32(1);
}

Referenced by ext4_xattr_write_to_disk().

ext4_xattr_set_inode_entry()

static void ext4_xattr_set_inode_entry ( struct ext4_xattr_item *  item, struct ext4_xattr_ibody_header *  ibody_header, struct ext4_xattr_entry *  entry, void *  ibody_data_ptr  )

static

Definition at line 833 of file ext4_xattr.c.

{
    entry->e_name_len = (__u8)item->name_len;
    entry->e_name_index = item->name_index;
    entry->e_value_offs =
       cpu_to_le16((char *)ibody_data_ptr - (char *)EXT4_XATTR_IFIRST(ibody_header));
    entry->e_value_block = 0;
    entry->e_value_size = cpu_to_le32(item->data_size);
}

Referenced by ext4_xattr_write_to_disk().

ext4_xattr_try_alloc_block()

static int ext4_xattr_try_alloc_block ( struct ext4_xattr_ref *  xattr_ref )

static

Definition at line 774 of file ext4_xattr.c.

{
    int ret = 0;

    ext4_fsblk_t xattr_block = 0;
    xattr_block = xattr_ref->inode_ref->Inode.i_file_acl;
    if (!xattr_block) {
        ext4_fsblk_t goal =
            ext4_inode_to_goal_block(&xattr_ref->inode_ref->Inode);

        xattr_block = ext4_new_meta_blocks(xattr_ref->IrpContext,
                          &xattr_ref->inode_ref->Inode,
                          goal, 0, NULL,
                          &ret);
        if (ret != 0)
            goto Finish;

        xattr_ref->block_bh = extents_bwrite(&xattr_ref->fs->sb, xattr_block);
        if (!xattr_ref->block_bh) {
            ext4_free_blocks(xattr_ref->IrpContext, &xattr_ref->inode_ref->Inode,
                           xattr_block, 1, 0);
            ret = -ENOMEM;
            goto Finish;
        }

        xattr_ref->inode_ref->Inode.i_file_acl = xattr_block;
        xattr_ref->IsOnDiskInodeDirty = TRUE;
        xattr_ref->block_loaded = TRUE;
    }

Finish:
    return ret;
}

Referenced by ext4_xattr_write_to_disk().

ext4_xattr_try_free_block()

static void ext4_xattr_try_free_block ( struct ext4_xattr_ref *  xattr_ref )

static

Definition at line 808 of file ext4_xattr.c.

{
    ext4_fsblk_t xattr_block;
    xattr_block = xattr_ref->inode_ref->Inode.i_file_acl;
    xattr_ref->inode_ref->Inode.i_file_acl = 0;
    extents_brelse(xattr_ref->block_bh);
    xattr_ref->block_bh = NULL;
    ext4_free_blocks(xattr_ref->IrpContext, &xattr_ref->inode_ref->Inode,
        xattr_block, 1, 0);
    xattr_ref->IsOnDiskInodeDirty = TRUE;
    xattr_ref->block_loaded = FALSE;
}

Referenced by ext4_xattr_write_to_disk().

ext4_xattr_write_to_disk()

static int ext4_xattr_write_to_disk ( struct ext4_xattr_ref *  xattr_ref )

static

Definition at line 858 of file ext4_xattr.c.

{
    int ret = 0;
    BOOL block_modified = FALSE;
    void *ibody_data = NULL;
    void *block_data = NULL;
    size_t inode_size_rem, block_size_rem;
    struct ext4_xattr_ibody_header *ibody_header = NULL;
    struct ext4_xattr_header *block_header = NULL;
    struct ext4_xattr_entry *entry = NULL;
    struct ext4_xattr_entry *block_entry = NULL;
    struct ext4_xattr_item *item = NULL;

    inode_size_rem = ext4_xattr_inode_space(xattr_ref);
    block_size_rem = ext4_xattr_block_space(xattr_ref);
    if (inode_size_rem > sizeof(struct ext4_xattr_ibody_header)) {
        ibody_header = EXT4_XATTR_IHDR(xattr_ref->OnDiskInode);
        entry = EXT4_XATTR_IFIRST(ibody_header);
    }

    if (!xattr_ref->dirty)
        goto Finish;
    /* If there are enough spaces in the ibody EA table.*/
    if (inode_size_rem > sizeof(struct ext4_xattr_ibody_header)) {
        memset(ibody_header, 0, inode_size_rem);
        ibody_header->h_magic = EXT4_XATTR_MAGIC;
        ibody_data = (char *)ibody_header + inode_size_rem;
        inode_size_rem -= sizeof(struct ext4_xattr_ibody_header);

        xattr_ref->IsOnDiskInodeDirty = TRUE;
    }
    /* If we need an extra block to hold the EA entries*/
    if (xattr_ref->ea_size > inode_size_rem) {
        if (!xattr_ref->block_loaded) {
            ret = ext4_xattr_try_alloc_block(xattr_ref);
            if (ret != 0)
                goto Finish;
        }
        memset(xattr_ref->block_bh->b_data, 0, xattr_ref->fs->BlockSize);
        block_header = EXT4_XATTR_BHDR(xattr_ref->block_bh);
        block_entry = EXT4_XATTR_BFIRST(xattr_ref->block_bh);
        ext4_xattr_set_block_header(xattr_ref);
        block_data = (char *)block_header + block_size_rem;
        block_size_rem -= sizeof(struct ext4_xattr_header);

        extents_mark_buffer_dirty(xattr_ref->block_bh);
    } else {
        /* We don't need an extra block.*/
        if (xattr_ref->block_loaded) {
            block_header = EXT4_XATTR_BHDR(xattr_ref->block_bh);
            le32_add_cpu(&block_header->h_refcount, -1);
            if (!block_header->h_refcount) {
                ext4_xattr_try_free_block(xattr_ref);
                block_header = NULL;
            } else {
                block_entry =
                    EXT4_XATTR_BFIRST(xattr_ref->block_bh);
                block_data =
                    (char *)block_header + block_size_rem;
                block_size_rem -=
                    sizeof(struct ext4_xattr_header);
                xattr_ref->inode_ref->Inode.i_file_acl = 0;

                xattr_ref->IsOnDiskInodeDirty = TRUE;
                extents_mark_buffer_dirty(xattr_ref->block_bh);
            }
        }
    }

    list_for_each_entry(item, &xattr_ref->ordered_list, struct ext4_xattr_item, list_node) {
        if (item->in_inode) {
            ibody_data = (char *)ibody_data -
                     EXT4_XATTR_SIZE(item->data_size);
            ext4_xattr_set_inode_entry(item, ibody_header, entry,
                           ibody_data);
            memcpy(EXT4_XATTR_NAME(entry), item->name,
                   item->name_len);
            memcpy(ibody_data, item->data, item->data_size);
            entry = EXT4_XATTR_NEXT(entry);
            inode_size_rem -= EXT4_XATTR_SIZE(item->data_size) +
                      EXT4_XATTR_LEN(item->name_len);

            xattr_ref->IsOnDiskInodeDirty = TRUE;
            continue;
        }
        if (EXT4_XATTR_SIZE(item->data_size) +
            EXT4_XATTR_LEN(item->name_len) >
            block_size_rem) {
            ret = -ENOSPC;
            DbgPrint("ext4_xattr.c: IMPOSSIBLE -ENOSPC AS WE DID INSPECTION!\n");
            ASSERT(0);
        }
        block_data =
            (char *)block_data - EXT4_XATTR_SIZE(item->data_size);
        ext4_xattr_set_block_entry(item, block_header, block_entry,
                       block_data);
        memcpy(EXT4_XATTR_NAME(block_entry), item->name,
               item->name_len);
        memcpy(block_data, item->data, item->data_size);
        ext4_xattr_compute_hash(block_header, block_entry);
        block_entry = EXT4_XATTR_NEXT(block_entry);
        block_size_rem -= EXT4_XATTR_SIZE(item->data_size) +
                  EXT4_XATTR_LEN(item->name_len);

        block_modified = TRUE;
    }
    xattr_ref->dirty = FALSE;
    if (block_modified) {
        ext4_xattr_rehash(block_header,
                  EXT4_XATTR_BFIRST(xattr_ref->block_bh));
        ext4_xattr_set_block_checksum(xattr_ref->inode_ref,
                          xattr_ref->block_bh->b_blocknr,
                          block_header);
        extents_mark_buffer_dirty(xattr_ref->block_bh);
    }

Finish:
    return ret;
}

Referenced by ext4_fs_put_xattr_ref().

Variable Documentation

prefix_tbl

const struct xattr_prefix prefix_tbl[]

static

Initial value:

= {
    {"user.", EXT4_XATTR_INDEX_USER},
    {"system.posix_acl_access", EXT4_XATTR_INDEX_POSIX_ACL_ACCESS},
    {"system.posix_acl_default", EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT},
    {"trusted.", EXT4_XATTR_INDEX_TRUSTED},
    {"security.", EXT4_XATTR_INDEX_SECURITY},
    {"system.", EXT4_XATTR_INDEX_SYSTEM},
    {"system.richacl", EXT4_XATTR_INDEX_RICHACL},
    {NULL, 0},
}

Definition at line 1223 of file ext4_xattr.c.

Referenced by ext4_extract_xattr_name(), and ext4_get_xattr_name_prefix().