From: Vyacheslav Dubeyko <[email protected]> Subject: [RFC][PATCH 10/15] nilfs2: implement setxattr and removexattr functionality
This patch adds functionality of setxattr and removexattr operations. Signed-off-by: Vyacheslav Dubeyko <[email protected]> CC: Ryusuke Konishi <[email protected]> --- fs/nilfs2/xafile.c | 598 ++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/nilfs2/xattr.c | 26 +++ fs/nilfs2/xattr.h | 15 ++ 3 files changed, 639 insertions(+) diff --git a/fs/nilfs2/xafile.c b/fs/nilfs2/xafile.c index e89e95b..dcc524f 100644 --- a/fs/nilfs2/xafile.c +++ b/fs/nilfs2/xafile.c @@ -1059,6 +1059,65 @@ failed_find_node: } /* + * is_value_size_valid - check that xattr can be stored in xanode + * @xafile: xafile's inode + * @node: pointer on xanode's begin + * @name: xattr name + * @value_size: xattr's value size + */ +static inline +bool is_value_size_valid(struct inode *xafile, char *node, + char *name, size_t value_size) +{ + return value_size <= + (NILFS_XAFILE_I(xafile)->mi.mi_entry_size - + (NILFS_XANODE_HDR_SIZE(NILFS_XANODE_HDR(node)) + + NILFS_XANODE_NOT_INDEX_KEY_SIZE(NILFS_XANODE_HDR(node)) + + NILFS_XANODE_END_KEY_SIZE + + strlen(name) + + value_size)); +} + +/* + * __can_insert_entries - check that entries can be stored in xanode + * @node_ptr: pointer on xanode's begin + * @entries_count: count of xattrs + * @entries_size: size of entries in bytes + */ +static inline +bool __can_insert_entries(char *node_ptr, + int entries_count, size_t entries_size) +{ + union nilfs_xanode_header *hdr = NILFS_XANODE_HDR(node_ptr); + char *begin_free_area = NULL; + char *end_free_area = NULL; + + begin_free_area = (char *)NILFS_XANODE_END_KEY(hdr); + begin_free_area += + (entries_count * NILFS_XANODE_NOT_INDEX_KEY_SIZE(hdr)); + begin_free_area += NILFS_XANODE_END_KEY_SIZE; + + end_free_area = (char*)NILFS_XANODE_LAST_ENTRY(hdr); + end_free_area -= entries_size; + + return begin_free_area <= end_free_area; +} + +/* + * can_insert_entry - check opportunity to insert xattr + * @node_ptr: pointer on xanode's begin + * @name: xattr's name + * @value_size: xattr's value size + */ +static inline +bool can_insert_entry(char *node_ptr, char *name, size_t value_size) +{ + u16 entry_size = NILFS_XATTR_ENTRY_SIZE(name, value_size); + + return __can_insert_entries(node_ptr, 1, entry_size); +} + +/* * __nilfs_xafile_node_init - initialize newly created xanode in memory * @inode: inode pointer * @node_type: xanode type @@ -1328,6 +1387,431 @@ void nilfs_xafile_abort_new_node(struct inode *inode, } /* + * nilfs_xafile_set_entry_for_key - add xattr as last entry by key + * @inode: inode pointer + * @name_index: xattr's name index + * @name: xattr's name + * @value: xattr's value + * @value_size: xattr's value size + * @node_ptr: pointer on xanode's begin + * @key: xanode's key + * @entry: xanode's entry + */ +static +int nilfs_xafile_set_entry_for_key(struct inode *inode, + int name_index, + const char *name, + const void *value, + size_t value_size, + char *node_ptr, + union nilfs_xattr_key *key, + struct nilfs_xanode_entry *entry) +{ + int err; + union nilfs_xanode_header *hdr = NILFS_XANODE_HDR(node_ptr); + ptrdiff_t entry_offset = NILFS_XATTR_ENTRY_OFFSET(node_ptr, entry); + __u32 entry_size = NILFS_XATTR_ENTRY_SIZE(name, value_size); + __u16 name_len = strlen(name); + __u32 *end_key; + + /* TODO: entry can have different structure */ + + /* insert entry */ + memcpy(entry->name, name, name_len); + memcpy(entry->name + name_len, value, value_size); + + /* insert key */ + switch (NILFS_XANODE_TYPE(node_ptr)) { + case NILFS_XATTR_TREE_XANODE_TYPE: + NILFS_XANODE_KEY_SET_TYPE(NILFS_XATTR_TREE_LEAF_KEY_TYPE, key); + + err = calc_name_hash(name_index, name, + &key->leaf_key.name_hash); + if (unlikely(err)) + return err; + + key->leaf_key.entry_offset = cpu_to_le16(entry_offset); + key->leaf_key.entry_size = cpu_to_le16(entry_size); + break; + + default: + BUG(); + }; + + NILFS_XANODE_ADD_ENTRIES(1, hdr); + end_key = NILFS_XANODE_END_KEY(hdr); + *end_key = NILFS_XANODE_END_KEY_VALUE; + + return 0; +} + +/* + * nilfs_xafile_insert_entry_for_key - insert xattr in xanode by key + * @inode: inode pointer + * @name_index: xattr's name index + * @name: xattr's name + * @value: xattr's value + * @value_size: xattr's value size + * @node_ptr: pointer on xanode's begin + * @key: xanode's key + */ +static +int nilfs_xafile_insert_entry_for_key(struct inode *inode, + int name_index, + const char *name, + const void *value, + size_t value_size, + char *node_ptr, + union nilfs_xattr_key *key) +{ + int err; + __u32 entry_size; + union nilfs_xattr_key *last_key; + char *old_last_entry_ptr; + char *new_last_entry_ptr; + __u32 shifted_entries_size; + char *end_key; + char *old_key_ptr = (char *)key; + char *new_key_ptr; + ptrdiff_t shifted_keys_size; + struct nilfs_xanode_entry *inserted; + union nilfs_xattr_key *cur_key; + union nilfs_xanode_header *hdr = NILFS_XANODE_HDR(node_ptr); + +#ifdef CONFIG_NILFS2_FS_DEBUG + BUG_ON(IS_END_KEY(key)); +#endif + + entry_size = NILFS_XATTR_ENTRY_SIZE(name, value_size); + last_key = NILFS_XANODE_LAST_NOT_INDEX_KEY(hdr); + +#ifdef CONFIG_NILFS2_FS_DEBUG + BUG_ON(IS_END_KEY(last_key)); +#endif + + old_last_entry_ptr = (char *)NILFS_XANODE_LAST_ENTRY(hdr); + new_last_entry_ptr = old_last_entry_ptr - entry_size; + shifted_entries_size = (NILFS_XANODE_ENTRY_OFFSET(last_key) - + NILFS_XANODE_ENTRY_OFFSET(key)) + + NILFS_XANODE_ENTRY_SIZE(key); + end_key = (char *)NILFS_XANODE_END_KEY(hdr); + new_key_ptr = old_key_ptr + NILFS_XANODE_NOT_INDEX_KEY_SIZE(hdr); + shifted_keys_size = (end_key - old_key_ptr) + NILFS_XANODE_END_KEY_SIZE; + inserted = (struct nilfs_xanode_entry *)(new_last_entry_ptr + + shifted_entries_size); + + /* shift entries */ + memmove(new_last_entry_ptr, + old_last_entry_ptr, shifted_entries_size); + + /* shift keys */ + memmove(new_key_ptr, old_key_ptr, shifted_keys_size); + + /* correct shifted keys */ + cur_key = NILFS_XANODE_KEY(new_key_ptr); + for (; !IS_END_KEY(cur_key); cur_key = NEXT_KEY(cur_key, 1)) + NILFS_XANODE_ADD_ENTRY_OFFSET(entry_size, cur_key); + + err = nilfs_xafile_set_entry_for_key(inode, + name_index, name, + value, value_size, + node_ptr, key, inserted); + + return err; +} + +/* + * nilfs_xafile_node_insert_entry - insert xattr in xanode + * @inode: inode pointer + * @data: internal xattr search structure + * @value: xattr's value + * @size: xattr's value size + */ +static +int nilfs_xafile_node_insert_entry(struct inode *inode, + struct nilfs_xattr_search *data, + const void *value, + size_t size) +{ + int err; + union nilfs_xanode_header *hdr; + struct nilfs_xanode_entry *inserted = NULL; + __u32 entry_size; + u8 name_index; + char *name; + +#ifdef CONFIG_NILFS2_FS_DEBUG + BUG_ON(!IS_SHADOW_XANODE_DESC(&data->node)); +#endif + + hdr = data->result.hdr; + + if (!can_insert_entry((char *)hdr, data->search.name, size)) + return -ENOSPC; + + /* TODO: entry size can be calculated on different basis */ + entry_size = NILFS_XATTR_ENTRY_SIZE(data->search.name, size); + + name_index = data->search.name_hash.name_index; + name = data->search.name; + + if (IS_END_KEY(data->result.key)) { + char *old_ptr = (char *)NILFS_XANODE_LAST_ENTRY(hdr); + + /* add entry */ + inserted = (struct nilfs_xanode_entry *)(old_ptr - entry_size); + err = nilfs_xafile_set_entry_for_key(inode, name_index, name, + value, size, + (char *)hdr, + data->result.key, + inserted); + if (unlikely(err)) + return err; + } else { + /* insert entry */ + err = nilfs_xafile_insert_entry_for_key(inode, name_index, name, + value, size, + (char *)hdr, + data->result.key); + if (unlikely(err)) + return err; + } + + return 0; +} + +/* + * nilfs_xafile_node_delete_entries - delete xattrs from xanode + * @inode: inode pointer + * @data: internal xattr search structure + * @entries_count: deleted xattrs count + */ +static +int nilfs_xafile_node_delete_entries(struct inode *inode, + struct nilfs_xattr_search *data, + int entries_count) +{ + int err; + union nilfs_xanode_header *hdr; + size_t node_size; + size_t key_size; + union nilfs_xattr_key *cur_key; + union nilfs_xattr_key *last_key; + union nilfs_xattr_key *last_del_key; + union nilfs_xattr_key *first_shift_key; + __u32 *end_key; + char *cur_entry; + char *last_entry; + __u32 removed_keys_size; + __u32 removed_entries_size; + +#ifdef CONFIG_NILFS2_FS_DEBUG + BUG_ON(IS_SEARCH_KEY_EMPTY(data)); + BUG_ON(IS_SEARCH_RESULT_EMPTY(data)); + BUG_ON(!IS_SHADOW_XANODE_DESC(&data->node)); +#endif + + if (!data->result.found) + return -EINVAL; + + cur_key = data->result.key; + cur_entry = (char *)data->result.entry; + + if (IS_END_KEY(cur_key)) { + printk(KERN_WARNING "NILFS warning: can't delete xattr\n"); + return -ENOENT; + } + + hdr = data->result.hdr; + node_size = NILFS_XANODE_SIZE; + end_key = NILFS_XANODE_END_KEY(hdr); + key_size = NILFS_XANODE_NOT_INDEX_KEY_SIZE(hdr); + removed_keys_size = entries_count * key_size; + + if (((char *)cur_key + removed_keys_size) > (char *)end_key) + return -EINVAL; + + err = nilfs_xafile_node_check_entries((char *)hdr, node_size); + if (unlikely(err < 0)) + return err; + + last_key = NILFS_XANODE_LAST_NOT_INDEX_KEY(hdr); + last_entry = (char *)NILFS_XANODE_LAST_ENTRY(hdr); + first_shift_key = NILFS_XANODE_KEY((char *)cur_key + removed_keys_size); + last_del_key = NILFS_XANODE_KEY((char *)first_shift_key - key_size); + + removed_entries_size = NILFS_XANODE_ENTRY_OFFSET(cur_key); + removed_entries_size -= NILFS_XANODE_ENTRY_OFFSET(last_del_key); + removed_entries_size += NILFS_XANODE_ENTRY_SIZE(last_del_key); + + /* shift entries */ + if (last_entry == (char *)cur_entry) { + size_t entry_size = NILFS_XANODE_ENTRY_SIZE(cur_key); + + memset((char *)data->result.entry, 0, entry_size); + } else { + char *new_last_entry; + __u32 shifted_size; + + new_last_entry = last_entry + removed_entries_size; + shifted_size = NILFS_XANODE_ENTRY_OFFSET(last_key); + shifted_size -= NILFS_XANODE_ENTRY_OFFSET(cur_key); + memmove(new_last_entry, last_entry, shifted_size); + } + + /* shift keys */ + if (last_key == cur_key) + memset(last_key, 0, key_size); + else { + char *old_key; + char *new_key; + + new_key = (char *)cur_key; + old_key = (char *)first_shift_key; + + if (IS_END_KEY(old_key)) + memset(new_key, 0, old_key - new_key); + else { + ptrdiff_t shifted_size; + + shifted_size = (char *)end_key - old_key; + shifted_size += NILFS_XANODE_END_KEY_SIZE; + memmove(new_key, old_key, shifted_size); + } + } + + /* correct shifted keys */ + for (; !IS_END_KEY(cur_key); cur_key = NEXT_KEY(cur_key, 1)) { + NILFS_XANODE_ADD_ENTRY_OFFSET(-1 * removed_entries_size, + cur_key); + } + + NILFS_XANODE_ADD_ENTRIES(-1 * entries_count, hdr); + return 0; +} + +/* + * nilfs_xafile_node_delete_entry - delete one xattr from xanode + * @inode: inode pointer + * @data: internal xattr search structure + */ +static inline +int nilfs_xafile_node_delete_entry(struct inode *inode, + struct nilfs_xattr_search *data) +{ + return nilfs_xafile_node_delete_entries(inode, data, 1); +} + +/* + * nilfs_xafile_set_entry - set xattr by shadow change and commit + * @inode: inode pointer + * @data: internal xattr search structure + * @value: xattr's value + * @size: xattr's value size + */ +static +int nilfs_xafile_set_entry(struct inode *inode, + struct nilfs_xattr_search *data, + const void *value, + size_t size) +{ + int err = 0; + struct the_nilfs *nilfs = inode->i_sb->s_fs_info; + struct inode *xafile = nilfs->ns_xafile; + bool can_insert = false; + + if (!value) + return -EINVAL; + if (!is_value_size_valid(xafile, BH_DATA(NODE_BH(&data->node)), + data->search.name, size)) + return -ENOSPC; + if (IS_SEARCH_RESULT_EMPTY(data)) { + printk(KERN_ERR "NILFS: inconsistent xattr search\n"); + return -EINVAL; + } + + err = nilfs_xafile_prepare_node_for_change(inode, data); + if (unlikely(err)) + goto set_entry_cleanup; + + if (data->result.found) { + err = nilfs_xafile_node_delete_entry(inode, data); + if (unlikely(err)) + goto set_entry_cleanup; + } + + can_insert = can_insert_entry((char *)data->result.hdr, + data->search.name, size); + + if (can_insert) { + err = nilfs_xafile_node_insert_entry(inode, data, value, size); + if (unlikely(err)) + goto set_entry_cleanup; + + nilfs_xafile_commit_changed_node(inode, data); + } else { + err = -ENOSPC; + goto set_entry_cleanup; + } + + return 0; + +set_entry_cleanup: + nilfs_xafile_abort_node_change(data); + return err; +} + +/* + * nilfs_xafile_delete_entry - delete xattr by shadow change and commit + * @inode: inode pointer + * @data: internal xattr search structure + */ +static +int nilfs_xafile_delete_entry(struct inode *inode, + struct nilfs_xattr_search *data) +{ + int err = 0; + struct the_nilfs *nilfs = inode->i_sb->s_fs_info; + struct inode *xafile = nilfs->ns_xafile; + + if (IS_SEARCH_RESULT_EMPTY(data)) { + printk(KERN_ERR "NILFS: inconsistent xattr search\n"); + return -EINVAL; + } + + err = nilfs_xafile_prepare_node_for_change(inode, data); + if (unlikely(err)) + goto delete_entry_cleanup; + + err = nilfs_xafile_node_delete_entry(inode, data); + if (unlikely(err)) + goto delete_entry_cleanup; + + if (NILFS_XANODE_ENTRIES(data->result.hdr) == 0) { + err = nilfs_xafile_prepare_node_deletion(xafile, + &data->node.req); + if (unlikely(err)) + goto delete_entry_cleanup; + + if (NILFS_I(inode)->i_xattr == NODE_ID(&data->node)) { + NILFS_I(inode)->i_xattr = NILFS_INVALID_XANODE; + nilfs_mark_inode_dirty(inode); + } + + nilfs_xafile_commit_node_deletion(xafile, &data->node.req); + } + + nilfs_xafile_commit_changed_node(inode, data); + + return 0; + +delete_entry_cleanup: + nilfs_xafile_abort_node_change(data); + + return err; +} + +/* * nilfs_xattr_list_entries - list inode's xattrs from one xanode * @dentry: dentry object * @bh: xanode's buffer @@ -1467,3 +1951,117 @@ failed_xafile_getxattr: nilfs_xattr_search_release(&data); return ret; } + +/* + * nilfs_xafile_setxattr - set/delete xattr + * @inode: inode pointer + * @name_index: name index of xattr + * @name: xattr's name + * @value: pointer on xattr's value + * @size: xattr's value size + * @flags: operation flags + */ +int nilfs_xafile_setxattr(struct inode *inode, + int name_index, const char *name, + const void *value, size_t size, int flags) +{ + int err = 0; + struct the_nilfs *nilfs = inode->i_sb->s_fs_info; + struct nilfs_xattr_search data; + + if (!nilfs_has_xafile(nilfs)) + return -EOPNOTSUPP; + + if (!name) + return -EINVAL; + if (strlen(name) > XATTR_NAME_MAX) + return -ERANGE; + + err = nilfs_xattr_search_init(inode, name_index, (char *)name, &data); + if (unlikely(err)) + return err; + + if (IS_NODE_DESC_INVALID(NODE_ID(&data.node))) { + err = nilfs_xafile_prepare_new_node(inode, &data); + if (unlikely(err)) { + nilfs_xafile_abort_new_node(inode, &data); + goto failed_xafile_setxattr; + } + + nilfs_xafile_commit_new_node(inode, &data); + + NILFS_I(inode)->i_xattr = NODE_ID(&data.node); + nilfs_mark_inode_dirty(inode); + } else + err = nilfs_xafile_find_node(inode, &data); + + if (unlikely(err && err != -ENODATA)) + goto failed_xafile_setxattr; + else if (!data.result.found) { + err = -ENODATA; + if (flags & XATTR_REPLACE) + goto cleanup; + err = 0; + if (!value) + goto cleanup; + } else { + err = -EEXIST; + if (flags & XATTR_CREATE) + goto cleanup; + } + + if (flags & XATTR_REPLACE) { + if (!value) { + err = nilfs_xafile_delete_entry(inode, &data); + if (unlikely(err)) + goto cleanup; + } else { + err = nilfs_xafile_set_entry(inode, &data, value, size); + if (unlikely(err)) + goto cleanup; + } + } else { + err = nilfs_xafile_set_entry(inode, &data, value, size); + if (unlikely(err)) + goto cleanup; + } + +cleanup: + brelse(NODE_BH(&data.node)); + +failed_xafile_setxattr: + nilfs_xattr_search_release(&data); + return err; +} + +/* + * nilfs_xafile_delete_inode - delete all xattrs during inode eviction + * @inode: inode pointer + */ +int nilfs_xafile_delete_inode(struct inode *inode) +{ + int err; + struct the_nilfs *nilfs = inode->i_sb->s_fs_info; + struct inode *xafile = nilfs->ns_xafile; + __u64 node = NILFS_I(inode)->i_xattr; + struct nilfs_palloc_req req = {0}; + + if (!nilfs_has_xafile(nilfs)) + return 0; + + if (node == NILFS_INVALID_XANODE) + return 0; + + req.pr_entry_nr = node; + + err = nilfs_xafile_prepare_node_deletion(xafile, &req); + if (unlikely(err)) { + printk(KERN_ERR "NILFS: can't delete xanode %llu\n", + node); + return err; + } + + nilfs_xafile_commit_node_deletion(xafile, &req); + + return 0; +} diff --git a/fs/nilfs2/xattr.c b/fs/nilfs2/xattr.c index 7be523a..2e2f5f5 100644 --- a/fs/nilfs2/xattr.c +++ b/fs/nilfs2/xattr.c @@ -62,3 +62,29 @@ ssize_t __nilfs_getxattr(struct inode *inode, return ret; } + +int __nilfs_setxattr(struct inode *inode, + int name_index, const char *name, + const void *value, size_t size, + int flags) +{ + int err; + + down_write(&NILFS_I(inode)->xattr_sem); + err = nilfs_xafile_setxattr(inode, name_index, name, + value, size, flags); + up_write(&NILFS_I(inode)->xattr_sem); + + return err; +} + +int nilfs_xattr_delete_inode(struct inode *inode) +{ + int err; + + down_write(&NILFS_I(inode)->xattr_sem); + err = nilfs_xafile_delete_inode(inode); + up_write(&NILFS_I(inode)->xattr_sem); + + return err; +} diff --git a/fs/nilfs2/xattr.h b/fs/nilfs2/xattr.h index 0736086..104a60d 100644 --- a/fs/nilfs2/xattr.h +++ b/fs/nilfs2/xattr.h @@ -39,6 +39,21 @@ static inline ssize_t nilfs_getxattr(struct dentry *dentry, return __nilfs_getxattr(dentry->d_inode, name_index, name, value, size); } +int __nilfs_setxattr(struct inode *inode, + int name_index, const char *name, + const void *value, size_t size, int flags); + +static inline int nilfs_setxattr(struct dentry *dentry, + int name_index, const char *name, + const void *value, size_t size, + int flags) +{ + return __nilfs_setxattr(dentry->d_inode, + name_index, name, + value, size, flags); +} + ssize_t nilfs_listxattr(struct dentry *dentry, char *buffer, size_t size); +int nilfs_xattr_delete_inode(struct inode *inode); #endif /* _NILFS_XATTR_H */ -- 1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe linux-nilfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
