fs/f2fs/xattr.c - third_party/linux - Git at Google

 /*
  * fs/f2fs/xattr.c
  *
  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
  *             http://www.samsung.com/
  *
  * Portions of this code from linux/fs/ext2/xattr.c
  *
  * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
  *
  * Fix by Harrison Xing <harrison@mountainviewdata.com>.
  * 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.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/rwsem.h>
 #include <linux/f2fs_fs.h>
 #include "f2fs.h"
 #include "xattr.h"

 static size_t f2fs_xattr_generic_list(struct dentry *dentry, char *list,
 		size_t list_size, const char *name, size_t name_len, int type)
 {
 	struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
 	int total_len, prefix_len = 0;
 	const char *prefix = NULL;

 	switch (type) {
 	case F2FS_XATTR_INDEX_USER:
 		if (!test_opt(sbi, XATTR_USER))
 			return -EOPNOTSUPP;
 		prefix = XATTR_USER_PREFIX;
 		prefix_len = XATTR_USER_PREFIX_LEN;
 		break;
 	case F2FS_XATTR_INDEX_TRUSTED:
 		if (!capable(CAP_SYS_ADMIN))
 			return -EPERM;
 		prefix = XATTR_TRUSTED_PREFIX;
 		prefix_len = XATTR_TRUSTED_PREFIX_LEN;
 		break;
 	default:
 		return -EINVAL;
 	}

 	total_len = prefix_len + name_len + 1;
 	if (list && total_len <= list_size) {
 		memcpy(list, prefix, prefix_len);
 		memcpy(list+prefix_len, name, name_len);
 		list[prefix_len + name_len] = '\0';
 	}
 	return total_len;
 }

 static int f2fs_xattr_generic_get(struct dentry *dentry, const char *name,
 		void *buffer, size_t size, int type)
 {
 	struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);

 	switch (type) {
 	case F2FS_XATTR_INDEX_USER:
 		if (!test_opt(sbi, XATTR_USER))
 			return -EOPNOTSUPP;
 		break;
 	case F2FS_XATTR_INDEX_TRUSTED:
 		if (!capable(CAP_SYS_ADMIN))
 			return -EPERM;
 		break;
 	default:
 		return -EINVAL;
 	}
 	if (strcmp(name, "") == 0)
 		return -EINVAL;
 	return f2fs_getxattr(dentry->d_inode, type, name,
 			buffer, size);
 }

 static int f2fs_xattr_generic_set(struct dentry *dentry, const char *name,
 		const void *value, size_t size, int flags, int type)
 {
 	struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);

 	switch (type) {
 	case F2FS_XATTR_INDEX_USER:
 		if (!test_opt(sbi, XATTR_USER))
 			return -EOPNOTSUPP;
 		break;
 	case F2FS_XATTR_INDEX_TRUSTED:
 		if (!capable(CAP_SYS_ADMIN))
 			return -EPERM;
 		break;
 	default:
 		return -EINVAL;
 	}
 	if (strcmp(name, "") == 0)
 		return -EINVAL;

 	return f2fs_setxattr(dentry->d_inode, type, name, value, size);
 }

 static size_t f2fs_xattr_advise_list(struct dentry *dentry, char *list,
 		size_t list_size, const char *name, size_t name_len, int type)
 {
 	const char *xname = F2FS_SYSTEM_ADVISE_PREFIX;
 	size_t size;

 	if (type != F2FS_XATTR_INDEX_ADVISE)
 		return 0;

 	size = strlen(xname) + 1;
 	if (list && size <= list_size)
 		memcpy(list, xname, size);
 	return size;
 }

 static int f2fs_xattr_advise_get(struct dentry *dentry, const char *name,
 		void *buffer, size_t size, int type)
 {
 	struct inode *inode = dentry->d_inode;

 	if (strcmp(name, "") != 0)
 		return -EINVAL;

 	*((char *)buffer) = F2FS_I(inode)->i_advise;
 	return sizeof(char);
 }

 static int f2fs_xattr_advise_set(struct dentry *dentry, const char *name,
 		const void *value, size_t size, int flags, int type)
 {
 	struct inode *inode = dentry->d_inode;

 	if (strcmp(name, "") != 0)
 		return -EINVAL;
 	if (!inode_owner_or_capable(inode))
 		return -EPERM;
 	if (value == NULL)
 		return -EINVAL;

 	F2FS_I(inode)->i_advise |= *(char *)value;
 	return 0;
 }

 const struct xattr_handler f2fs_xattr_user_handler = {
 	.prefix	= XATTR_USER_PREFIX,
 	.flags	= F2FS_XATTR_INDEX_USER,
 	.list	= f2fs_xattr_generic_list,
 	.get	= f2fs_xattr_generic_get,
 	.set	= f2fs_xattr_generic_set,
 };

 const struct xattr_handler f2fs_xattr_trusted_handler = {
 	.prefix	= XATTR_TRUSTED_PREFIX,
 	.flags	= F2FS_XATTR_INDEX_TRUSTED,
 	.list	= f2fs_xattr_generic_list,
 	.get	= f2fs_xattr_generic_get,
 	.set	= f2fs_xattr_generic_set,
 };

 const struct xattr_handler f2fs_xattr_advise_handler = {
 	.prefix = F2FS_SYSTEM_ADVISE_PREFIX,
 	.flags	= F2FS_XATTR_INDEX_ADVISE,
 	.list   = f2fs_xattr_advise_list,
 	.get    = f2fs_xattr_advise_get,
 	.set    = f2fs_xattr_advise_set,
 };

 static const struct xattr_handler *f2fs_xattr_handler_map[] = {
 	[F2FS_XATTR_INDEX_USER] = &f2fs_xattr_user_handler,
 #ifdef CONFIG_F2FS_FS_POSIX_ACL
 	[F2FS_XATTR_INDEX_POSIX_ACL_ACCESS] = &f2fs_xattr_acl_access_handler,
 	[F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT] = &f2fs_xattr_acl_default_handler,
 #endif
 	[F2FS_XATTR_INDEX_TRUSTED] = &f2fs_xattr_trusted_handler,
 	[F2FS_XATTR_INDEX_ADVISE] = &f2fs_xattr_advise_handler,
 };

 const struct xattr_handler *f2fs_xattr_handlers[] = {
 	&f2fs_xattr_user_handler,
 #ifdef CONFIG_F2FS_FS_POSIX_ACL
 	&f2fs_xattr_acl_access_handler,
 	&f2fs_xattr_acl_default_handler,
 #endif
 	&f2fs_xattr_trusted_handler,
 	&f2fs_xattr_advise_handler,
 	NULL,
 };

 static inline const struct xattr_handler *f2fs_xattr_handler(int name_index)
 {
 	const struct xattr_handler *handler = NULL;

 	if (name_index > 0 && name_index < ARRAY_SIZE(f2fs_xattr_handler_map))
 		handler = f2fs_xattr_handler_map[name_index];
 	return handler;
 }

 int f2fs_getxattr(struct inode *inode, int name_index, const char *name,
 		void *buffer, size_t buffer_size)
 {
 	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
 	struct f2fs_inode_info *fi = F2FS_I(inode);
 	struct f2fs_xattr_entry *entry;
 	struct page *page;
 	void *base_addr;
 	int error = 0, found = 0;
 	size_t value_len, name_len;

 	if (name == NULL)
 		return -EINVAL;
 	name_len = strlen(name);

 	if (!fi->i_xattr_nid)
 		return -ENODATA;

 	page = get_node_page(sbi, fi->i_xattr_nid);
 	base_addr = page_address(page);

 	list_for_each_xattr(entry, base_addr) {
 		if (entry->e_name_index != name_index)
 			continue;
 		if (entry->e_name_len != name_len)
 			continue;
 		if (!memcmp(entry->e_name, name, name_len)) {
 			found = 1;
 			break;
 		}
 	}
 	if (!found) {
 		error = -ENODATA;
 		goto cleanup;
 	}

 	value_len = le16_to_cpu(entry->e_value_size);

 	if (buffer && value_len > buffer_size) {
 		error = -ERANGE;
 		goto cleanup;
 	}

 	if (buffer) {
 		char *pval = entry->e_name + entry->e_name_len;
 		memcpy(buffer, pval, value_len);
 	}
 	error = value_len;

 cleanup:
 	f2fs_put_page(page, 1);
 	return error;
 }

 ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
 	struct inode *inode = dentry->d_inode;
 	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
 	struct f2fs_inode_info *fi = F2FS_I(inode);
 	struct f2fs_xattr_entry *entry;
 	struct page *page;
 	void *base_addr;
 	int error = 0;
 	size_t rest = buffer_size;

 	if (!fi->i_xattr_nid)
 		return 0;

 	page = get_node_page(sbi, fi->i_xattr_nid);
 	base_addr = page_address(page);

 	list_for_each_xattr(entry, base_addr) {
 		const struct xattr_handler *handler =
 			f2fs_xattr_handler(entry->e_name_index);
 		size_t size;

 		if (!handler)
 			continue;

 		size = handler->list(dentry, buffer, rest, entry->e_name,
 				entry->e_name_len, handler->flags);
 		if (buffer && size > rest) {
 			error = -ERANGE;
 			goto cleanup;
 		}

 		if (buffer)
 			buffer += size;
 		rest -= size;
 	}
 	error = buffer_size - rest;
 cleanup:
 	f2fs_put_page(page, 1);
 	return error;
 }

 int f2fs_setxattr(struct inode *inode, int name_index, const char *name,
 					const void *value, size_t value_len)
 {
 	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
 	struct f2fs_inode_info *fi = F2FS_I(inode);
 	struct f2fs_xattr_header *header = NULL;
 	struct f2fs_xattr_entry *here, *last;
 	struct page *page;
 	void *base_addr;
 	int error, found, free, newsize;
 	size_t name_len;
 	char *pval;

 	if (name == NULL)
 		return -EINVAL;
 	name_len = strlen(name);

 	if (value == NULL)
 		value_len = 0;

 	if (name_len > 255 || value_len > MAX_VALUE_LEN)
 		return -ERANGE;

 	f2fs_balance_fs(sbi);

 	mutex_lock_op(sbi, NODE_NEW);
 	if (!fi->i_xattr_nid) {
 		/* Allocate new attribute block */
 		struct dnode_of_data dn;

 		if (!alloc_nid(sbi, &fi->i_xattr_nid)) {
 			mutex_unlock_op(sbi, NODE_NEW);
 			return -ENOSPC;
 		}
 		set_new_dnode(&dn, inode, NULL, NULL, fi->i_xattr_nid);
 		mark_inode_dirty(inode);

 		page = new_node_page(&dn, XATTR_NODE_OFFSET);
 		if (IS_ERR(page)) {
 			alloc_nid_failed(sbi, fi->i_xattr_nid);
 			fi->i_xattr_nid = 0;
 			mutex_unlock_op(sbi, NODE_NEW);
 			return PTR_ERR(page);
 		}

 		alloc_nid_done(sbi, fi->i_xattr_nid);
 		base_addr = page_address(page);
 		header = XATTR_HDR(base_addr);
 		header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC);
 		header->h_refcount = cpu_to_le32(1);
 	} else {
 		/* The inode already has an extended attribute block. */
 		page = get_node_page(sbi, fi->i_xattr_nid);
 		if (IS_ERR(page)) {
 			mutex_unlock_op(sbi, NODE_NEW);
 			return PTR_ERR(page);
 		}

 		base_addr = page_address(page);
 		header = XATTR_HDR(base_addr);
 	}

 	if (le32_to_cpu(header->h_magic) != F2FS_XATTR_MAGIC) {
 		error = -EIO;
 		goto cleanup;
 	}

 	/* find entry with wanted name. */
 	found = 0;
 	list_for_each_xattr(here, base_addr) {
 		if (here->e_name_index != name_index)
 			continue;
 		if (here->e_name_len != name_len)
 			continue;
 		if (!memcmp(here->e_name, name, name_len)) {
 			found = 1;
 			break;
 		}
 	}

 	last = here;

 	while (!IS_XATTR_LAST_ENTRY(last))
 		last = XATTR_NEXT_ENTRY(last);

 	newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) +
 			name_len + value_len);

 	/* 1. Check space */
 	if (value) {
 		/* If value is NULL, it is remove operation.
 		 * In case of update operation, we caculate free.
 		 */
 		free = MIN_OFFSET - ((char *)last - (char *)header);
 		if (found)
 			free = free - ENTRY_SIZE(here);

 		if (free < newsize) {
 			error = -ENOSPC;
 			goto cleanup;
 		}
 	}

 	/* 2. Remove old entry */
 	if (found) {
 		/* If entry is found, remove old entry.
 		 * If not found, remove operation is not needed.
 		 */
 		struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);
 		int oldsize = ENTRY_SIZE(here);

 		memmove(here, next, (char *)last - (char *)next);
 		last = (struct f2fs_xattr_entry *)((char *)last - oldsize);
 		memset(last, 0, oldsize);
 	}

 	/* 3. Write new entry */
 	if (value) {
 		/* Before we come here, old entry is removed.
 		 * We just write new entry. */
 		memset(last, 0, newsize);
 		last->e_name_index = name_index;
 		last->e_name_len = name_len;
 		memcpy(last->e_name, name, name_len);
 		pval = last->e_name + name_len;
 		memcpy(pval, value, value_len);
 		last->e_value_size = cpu_to_le16(value_len);
 	}

 	set_page_dirty(page);
 	f2fs_put_page(page, 1);

 	if (is_inode_flag_set(fi, FI_ACL_MODE)) {
 		inode->i_mode = fi->i_acl_mode;
 		inode->i_ctime = CURRENT_TIME;
 		clear_inode_flag(fi, FI_ACL_MODE);
 	}
 	f2fs_write_inode(inode, NULL);
 	mutex_unlock_op(sbi, NODE_NEW);

 	return 0;
 cleanup:
 	f2fs_put_page(page, 1);
 	mutex_unlock_op(sbi, NODE_NEW);
 	return error;
 }
	/*
	* fs/f2fs/xattr.c
	*
	* Copyright (c) 2012 Samsung Electronics Co., Ltd.
	* http://www.samsung.com/
	*
	* Portions of this code from linux/fs/ext2/xattr.c
	*
	* Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
	*
	* Fix by Harrison Xing <harrison@mountainviewdata.com>.
	* 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.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*/
	#include <linux/rwsem.h>
	#include <linux/f2fs_fs.h>
	#include "f2fs.h"
	#include "xattr.h"

	static size_t f2fs_xattr_generic_list(struct dentry dentry, char list,
	size_t list_size, const char *name, size_t name_len, int type)
	{
	struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
	int total_len, prefix_len = 0;
	const char *prefix = NULL;

	switch (type) {
	case F2FS_XATTR_INDEX_USER:
	if (!test_opt(sbi, XATTR_USER))
	return -EOPNOTSUPP;
	prefix = XATTR_USER_PREFIX;
	prefix_len = XATTR_USER_PREFIX_LEN;
	break;
	case F2FS_XATTR_INDEX_TRUSTED:
	if (!capable(CAP_SYS_ADMIN))
	return -EPERM;
	prefix = XATTR_TRUSTED_PREFIX;
	prefix_len = XATTR_TRUSTED_PREFIX_LEN;
	break;
	default:
	return -EINVAL;
	}

	total_len = prefix_len + name_len + 1;
	if (list && total_len <= list_size) {
	memcpy(list, prefix, prefix_len);
	memcpy(list+prefix_len, name, name_len);
	list[prefix_len + name_len] = '\0';
	}
	return total_len;
	}

	static int f2fs_xattr_generic_get(struct dentry dentry, const char name,
	void *buffer, size_t size, int type)
	{
	struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);

	switch (type) {
	case F2FS_XATTR_INDEX_USER:
	if (!test_opt(sbi, XATTR_USER))
	return -EOPNOTSUPP;
	break;
	case F2FS_XATTR_INDEX_TRUSTED:
	if (!capable(CAP_SYS_ADMIN))
	return -EPERM;
	break;
	default:
	return -EINVAL;
	}
	if (strcmp(name, "") == 0)
	return -EINVAL;
	return f2fs_getxattr(dentry->d_inode, type, name,
	buffer, size);
	}

	static int f2fs_xattr_generic_set(struct dentry dentry, const char name,
	const void *value, size_t size, int flags, int type)
	{
	struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);

	switch (type) {
	case F2FS_XATTR_INDEX_USER:
	if (!test_opt(sbi, XATTR_USER))
	return -EOPNOTSUPP;
	break;
	case F2FS_XATTR_INDEX_TRUSTED:
	if (!capable(CAP_SYS_ADMIN))
	return -EPERM;
	break;
	default:
	return -EINVAL;
	}
	if (strcmp(name, "") == 0)
	return -EINVAL;

	return f2fs_setxattr(dentry->d_inode, type, name, value, size);
	}

	static size_t f2fs_xattr_advise_list(struct dentry dentry, char list,
	size_t list_size, const char *name, size_t name_len, int type)
	{
	const char *xname = F2FS_SYSTEM_ADVISE_PREFIX;
	size_t size;

	if (type != F2FS_XATTR_INDEX_ADVISE)
	return 0;

	size = strlen(xname) + 1;
	if (list && size <= list_size)
	memcpy(list, xname, size);
	return size;
	}

	static int f2fs_xattr_advise_get(struct dentry dentry, const char name,
	void *buffer, size_t size, int type)
	{
	struct inode *inode = dentry->d_inode;

	if (strcmp(name, "") != 0)
	return -EINVAL;

	((char )buffer) = F2FS_I(inode)->i_advise;
	return sizeof(char);
	}

	static int f2fs_xattr_advise_set(struct dentry dentry, const char name,
	const void *value, size_t size, int flags, int type)
	{
	struct inode *inode = dentry->d_inode;

	if (strcmp(name, "") != 0)
	return -EINVAL;
	if (!inode_owner_or_capable(inode))
	return -EPERM;
	if (value == NULL)
	return -EINVAL;

	F2FS_I(inode)->i_advise \|= (char )value;
	return 0;
	}

	const struct xattr_handler f2fs_xattr_user_handler = {
	.prefix = XATTR_USER_PREFIX,
	.flags = F2FS_XATTR_INDEX_USER,
	.list = f2fs_xattr_generic_list,
	.get = f2fs_xattr_generic_get,
	.set = f2fs_xattr_generic_set,
	};

	const struct xattr_handler f2fs_xattr_trusted_handler = {
	.prefix = XATTR_TRUSTED_PREFIX,
	.flags = F2FS_XATTR_INDEX_TRUSTED,
	.list = f2fs_xattr_generic_list,
	.get = f2fs_xattr_generic_get,
	.set = f2fs_xattr_generic_set,
	};

	const struct xattr_handler f2fs_xattr_advise_handler = {
	.prefix = F2FS_SYSTEM_ADVISE_PREFIX,
	.flags = F2FS_XATTR_INDEX_ADVISE,
	.list = f2fs_xattr_advise_list,
	.get = f2fs_xattr_advise_get,
	.set = f2fs_xattr_advise_set,
	};

	static const struct xattr_handler *f2fs_xattr_handler_map[] = {
	[F2FS_XATTR_INDEX_USER] = &f2fs_xattr_user_handler,
	#ifdef CONFIG_F2FS_FS_POSIX_ACL
	[F2FS_XATTR_INDEX_POSIX_ACL_ACCESS] = &f2fs_xattr_acl_access_handler,
	[F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT] = &f2fs_xattr_acl_default_handler,
	#endif
	[F2FS_XATTR_INDEX_TRUSTED] = &f2fs_xattr_trusted_handler,
	[F2FS_XATTR_INDEX_ADVISE] = &f2fs_xattr_advise_handler,
	};

	const struct xattr_handler *f2fs_xattr_handlers[] = {
	&f2fs_xattr_user_handler,
	#ifdef CONFIG_F2FS_FS_POSIX_ACL
	&f2fs_xattr_acl_access_handler,
	&f2fs_xattr_acl_default_handler,
	#endif
	&f2fs_xattr_trusted_handler,
	&f2fs_xattr_advise_handler,
	NULL,
	};

	static inline const struct xattr_handler *f2fs_xattr_handler(int name_index)
	{
	const struct xattr_handler *handler = NULL;

	if (name_index > 0 && name_index < ARRAY_SIZE(f2fs_xattr_handler_map))
	handler = f2fs_xattr_handler_map[name_index];
	return handler;
	}

	int f2fs_getxattr(struct inode inode, int name_index, const char name,
	void *buffer, size_t buffer_size)
	{
	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
	struct f2fs_inode_info *fi = F2FS_I(inode);
	struct f2fs_xattr_entry *entry;
	struct page *page;
	void *base_addr;
	int error = 0, found = 0;
	size_t value_len, name_len;

	if (name == NULL)
	return -EINVAL;
	name_len = strlen(name);

	if (!fi->i_xattr_nid)
	return -ENODATA;

	page = get_node_page(sbi, fi->i_xattr_nid);
	base_addr = page_address(page);

	list_for_each_xattr(entry, base_addr) {
	if (entry->e_name_index != name_index)
	continue;
	if (entry->e_name_len != name_len)
	continue;
	if (!memcmp(entry->e_name, name, name_len)) {
	found = 1;
	break;
	}
	}
	if (!found) {
	error = -ENODATA;
	goto cleanup;
	}

	value_len = le16_to_cpu(entry->e_value_size);

	if (buffer && value_len > buffer_size) {
	error = -ERANGE;
	goto cleanup;
	}

	if (buffer) {
	char *pval = entry->e_name + entry->e_name_len;
	memcpy(buffer, pval, value_len);
	}
	error = value_len;

	cleanup:
	f2fs_put_page(page, 1);
	return error;
	}

	ssize_t f2fs_listxattr(struct dentry dentry, char buffer, size_t buffer_size)
	{
	struct inode *inode = dentry->d_inode;
	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
	struct f2fs_inode_info *fi = F2FS_I(inode);
	struct f2fs_xattr_entry *entry;
	struct page *page;
	void *base_addr;
	int error = 0;
	size_t rest = buffer_size;

	if (!fi->i_xattr_nid)
	return 0;

	page = get_node_page(sbi, fi->i_xattr_nid);
	base_addr = page_address(page);

	list_for_each_xattr(entry, base_addr) {
	const struct xattr_handler *handler =
	f2fs_xattr_handler(entry->e_name_index);
	size_t size;

	if (!handler)
	continue;

	size = handler->list(dentry, buffer, rest, entry->e_name,
	entry->e_name_len, handler->flags);
	if (buffer && size > rest) {
	error = -ERANGE;
	goto cleanup;
	}

	if (buffer)
	buffer += size;
	rest -= size;
	}
	error = buffer_size - rest;
	cleanup:
	f2fs_put_page(page, 1);
	return error;
	}

	int f2fs_setxattr(struct inode inode, int name_index, const char name,
	const void *value, size_t value_len)
	{
	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
	struct f2fs_inode_info *fi = F2FS_I(inode);
	struct f2fs_xattr_header *header = NULL;
	struct f2fs_xattr_entry here, last;
	struct page *page;
	void *base_addr;
	int error, found, free, newsize;
	size_t name_len;
	char *pval;

	if (name == NULL)
	return -EINVAL;
	name_len = strlen(name);

	if (value == NULL)
	value_len = 0;

	if (name_len > 255 \|\| value_len > MAX_VALUE_LEN)
	return -ERANGE;

	f2fs_balance_fs(sbi);

	mutex_lock_op(sbi, NODE_NEW);
	if (!fi->i_xattr_nid) {
	/* Allocate new attribute block */
	struct dnode_of_data dn;

	if (!alloc_nid(sbi, &fi->i_xattr_nid)) {
	mutex_unlock_op(sbi, NODE_NEW);
	return -ENOSPC;
	}
	set_new_dnode(&dn, inode, NULL, NULL, fi->i_xattr_nid);
	mark_inode_dirty(inode);

	page = new_node_page(&dn, XATTR_NODE_OFFSET);
	if (IS_ERR(page)) {
	alloc_nid_failed(sbi, fi->i_xattr_nid);
	fi->i_xattr_nid = 0;
	mutex_unlock_op(sbi, NODE_NEW);
	return PTR_ERR(page);
	}

	alloc_nid_done(sbi, fi->i_xattr_nid);
	base_addr = page_address(page);
	header = XATTR_HDR(base_addr);
	header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC);
	header->h_refcount = cpu_to_le32(1);
	} else {
	/* The inode already has an extended attribute block. */
	page = get_node_page(sbi, fi->i_xattr_nid);
	if (IS_ERR(page)) {
	mutex_unlock_op(sbi, NODE_NEW);
	return PTR_ERR(page);
	}

	base_addr = page_address(page);
	header = XATTR_HDR(base_addr);
	}

	if (le32_to_cpu(header->h_magic) != F2FS_XATTR_MAGIC) {
	error = -EIO;
	goto cleanup;
	}

	/* find entry with wanted name. */
	found = 0;
	list_for_each_xattr(here, base_addr) {
	if (here->e_name_index != name_index)
	continue;
	if (here->e_name_len != name_len)
	continue;
	if (!memcmp(here->e_name, name, name_len)) {
	found = 1;
	break;
	}
	}

	last = here;

	while (!IS_XATTR_LAST_ENTRY(last))
	last = XATTR_NEXT_ENTRY(last);

	newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) +
	name_len + value_len);

	/* 1. Check space */
	if (value) {
	/* If value is NULL, it is remove operation.
	* In case of update operation, we caculate free.
	*/
	free = MIN_OFFSET - ((char )last - (char )header);
	if (found)
	free = free - ENTRY_SIZE(here);

	if (free < newsize) {
	error = -ENOSPC;
	goto cleanup;
	}
	}

	/* 2. Remove old entry */
	if (found) {
	/* If entry is found, remove old entry.
	* If not found, remove operation is not needed.
	*/
	struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);
	int oldsize = ENTRY_SIZE(here);

	memmove(here, next, (char )last - (char )next);
	last = (struct f2fs_xattr_entry )((char )last - oldsize);
	memset(last, 0, oldsize);
	}

	/* 3. Write new entry */
	if (value) {
	/* Before we come here, old entry is removed.
	* We just write new entry. */
	memset(last, 0, newsize);
	last->e_name_index = name_index;
	last->e_name_len = name_len;
	memcpy(last->e_name, name, name_len);
	pval = last->e_name + name_len;
	memcpy(pval, value, value_len);
	last->e_value_size = cpu_to_le16(value_len);
	}

	set_page_dirty(page);
	f2fs_put_page(page, 1);

	if (is_inode_flag_set(fi, FI_ACL_MODE)) {
	inode->i_mode = fi->i_acl_mode;
	inode->i_ctime = CURRENT_TIME;
	clear_inode_flag(fi, FI_ACL_MODE);
	}
	f2fs_write_inode(inode, NULL);
	mutex_unlock_op(sbi, NODE_NEW);

	return 0;
	cleanup:
	f2fs_put_page(page, 1);
	mutex_unlock_op(sbi, NODE_NEW);
	return error;
	}