Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 38f38657 authored by Aristeu Rozanski's avatar Aristeu Rozanski Committed by Tejun Heo
Browse files

xattr: extract simple_xattr code from tmpfs 



Extract in-memory xattr APIs from tmpfs. Will be used by cgroup.

$ size vmlinux.o
   text    data     bss     dec     hex filename
4658782  880729 5195032 10734543         a3cbcf vmlinux.o
$ size vmlinux.o
   text    data     bss     dec     hex filename
4658957  880729 5195032 10734718         a3cc7e vmlinux.o

v7:
- checkpatch warnings fixed
- Implement the changes requested by Hugh Dickins:
	- make simple_xattrs_init and simple_xattrs_free inline
	- get rid of locking and list reinitialization in simple_xattrs_free,
	  they're not needed
v6:
- no changes
v5:
- no changes
v4:
- move simple_xattrs_free() to fs/xattr.c
v3:
- in kmem_xattrs_free(), reinitialize the list
- use simple_xattr_* prefix
- introduce simple_xattr_add() to prevent direct list usage

Original-patch-by: default avatarLi Zefan <lizefan@huawei.com>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Hillf Danton <dhillf@gmail.com>
Cc: Lennart Poettering <lpoetter@redhat.com>
Acked-by: default avatarHugh Dickins <hughd@google.com>
Signed-off-by: default avatarLi Zefan <lizefan@huawei.com>
Signed-off-by: default avatarAristeu Rozanski <aris@redhat.com>
Signed-off-by: default avatarTejun Heo <tj@kernel.org>
parent fea7a08a

fs/xattr.c

+166 −0
Original line number Diff line number Diff line
@@ -791,3 +791,169 @@ EXPORT_SYMBOL(generic_getxattr); 
EXPORT_SYMBOL(generic_listxattr);

EXPORT_SYMBOL(generic_setxattr);

EXPORT_SYMBOL(generic_removexattr);



/*

 * Allocate new xattr and copy in the value; but leave the name to callers.

 */

struct simple_xattr *simple_xattr_alloc(const void *value, size_t size)

{

	struct simple_xattr *new_xattr;

	size_t len;



	/* wrap around? */

	len = sizeof(*new_xattr) + size;

	if (len <= sizeof(*new_xattr))

		return NULL;



	new_xattr = kmalloc(len, GFP_KERNEL);

	if (!new_xattr)

		return NULL;



	new_xattr->size = size;

	memcpy(new_xattr->value, value, size);

	return new_xattr;

}



/*

 * xattr GET operation for in-memory/pseudo filesystems

 */

int simple_xattr_get(struct simple_xattrs *xattrs, const char *name,

		     void *buffer, size_t size)

{

	struct simple_xattr *xattr;

	int ret = -ENODATA;



	spin_lock(&xattrs->lock);

	list_for_each_entry(xattr, &xattrs->head, list) {

		if (strcmp(name, xattr->name))

			continue;



		ret = xattr->size;

		if (buffer) {

			if (size < xattr->size)

				ret = -ERANGE;

			else

				memcpy(buffer, xattr->value, xattr->size);

		}

		break;

	}

	spin_unlock(&xattrs->lock);

	return ret;

}



static int __simple_xattr_set(struct simple_xattrs *xattrs, const char *name,

			      const void *value, size_t size, int flags)

{

	struct simple_xattr *xattr;

	struct simple_xattr *new_xattr = NULL;

	int err = 0;



	/* value == NULL means remove */

	if (value) {

		new_xattr = simple_xattr_alloc(value, size);

		if (!new_xattr)

			return -ENOMEM;



		new_xattr->name = kstrdup(name, GFP_KERNEL);

		if (!new_xattr->name) {

			kfree(new_xattr);

			return -ENOMEM;

		}

	}



	spin_lock(&xattrs->lock);

	list_for_each_entry(xattr, &xattrs->head, list) {

		if (!strcmp(name, xattr->name)) {

			if (flags & XATTR_CREATE) {

				xattr = new_xattr;

				err = -EEXIST;

			} else if (new_xattr) {

				list_replace(&xattr->list, &new_xattr->list);

			} else {

				list_del(&xattr->list);

			}

			goto out;

		}

	}

	if (flags & XATTR_REPLACE) {

		xattr = new_xattr;

		err = -ENODATA;

	} else {

		list_add(&new_xattr->list, &xattrs->head);

		xattr = NULL;

	}

out:

	spin_unlock(&xattrs->lock);

	if (xattr) {

		kfree(xattr->name);

		kfree(xattr);

	}

	return err;



}



/*

 * xattr SET operation for in-memory/pseudo filesystems

 */

int simple_xattr_set(struct simple_xattrs *xattrs, const char *name,

		     const void *value, size_t size, int flags)

{

	if (size == 0)

		value = ""; /* empty EA, do not remove */

	return __simple_xattr_set(xattrs, name, value, size, flags);

}



/*

 * xattr REMOVE operation for in-memory/pseudo filesystems

 */

int simple_xattr_remove(struct simple_xattrs *xattrs, const char *name)

{

	return __simple_xattr_set(xattrs, name, NULL, 0, XATTR_REPLACE);

}



static bool xattr_is_trusted(const char *name)

{

	return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);

}



/*

 * xattr LIST operation for in-memory/pseudo filesystems

 */

ssize_t simple_xattr_list(struct simple_xattrs *xattrs, char *buffer,

			  size_t size)

{

	bool trusted = capable(CAP_SYS_ADMIN);

	struct simple_xattr *xattr;

	size_t used = 0;



	spin_lock(&xattrs->lock);

	list_for_each_entry(xattr, &xattrs->head, list) {

		size_t len;



		/* skip "trusted." attributes for unprivileged callers */

		if (!trusted && xattr_is_trusted(xattr->name))

			continue;



		len = strlen(xattr->name) + 1;

		used += len;

		if (buffer) {

			if (size < used) {

				used = -ERANGE;

				break;

			}

			memcpy(buffer, xattr->name, len);

			buffer += len;

		}

	}

	spin_unlock(&xattrs->lock);



	return used;

}



void simple_xattr_list_add(struct simple_xattrs *xattrs,

			   struct simple_xattr *new_xattr)

{

	spin_lock(&xattrs->lock);

	list_add(&new_xattr->list, &xattrs->head);

	spin_unlock(&xattrs->lock);

}

include/linux/shmem_fs.h

+2 −1
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 
#include <linux/mempolicy.h>

#include <linux/pagemap.h>

#include <linux/percpu_counter.h>

#include <linux/xattr.h>



/* inode in-kernel data */
@@ -18,7 +19,7 @@ struct shmem_inode_info { 
	};

	struct shared_policy	policy;		/* NUMA memory alloc policy */

	struct list_head	swaplist;	/* chain of maybes on swap */

	struct list_head	xattr_list;	/* list of shmem_xattr */

	struct simple_xattrs	xattrs;		/* list of xattrs */

	struct inode		vfs_inode;

};

include/linux/xattr.h

+48 −0
Original line number Diff line number Diff line
@@ -59,7 +59,9 @@ 


#ifdef  __KERNEL__



#include <linux/slab.h>

#include <linux/types.h>

#include <linux/spinlock.h>



struct inode;

struct dentry;
@@ -96,6 +98,52 @@ ssize_t vfs_getxattr_alloc(struct dentry *dentry, const char *name, 
			   char **xattr_value, size_t size, gfp_t flags);

int vfs_xattr_cmp(struct dentry *dentry, const char *xattr_name,

		  const char *value, size_t size, gfp_t flags);



struct simple_xattrs {

	struct list_head head;

	spinlock_t lock;

};



struct simple_xattr {

	struct list_head list;

	char *name;

	size_t size;

	char value[0];

};



/*

 * initialize the simple_xattrs structure

 */

static inline void simple_xattrs_init(struct simple_xattrs *xattrs)

{

	INIT_LIST_HEAD(&xattrs->head);

	spin_lock_init(&xattrs->lock);

}



/*

 * free all the xattrs

 */

static inline void simple_xattrs_free(struct simple_xattrs *xattrs)

{

	struct simple_xattr *xattr, *node;



	list_for_each_entry_safe(xattr, node, &xattrs->head, list) {

		kfree(xattr->name);

		kfree(xattr);

	}

}



struct simple_xattr *simple_xattr_alloc(const void *value, size_t size);

int simple_xattr_get(struct simple_xattrs *xattrs, const char *name,

		     void *buffer, size_t size);

int simple_xattr_set(struct simple_xattrs *xattrs, const char *name,

		     const void *value, size_t size, int flags);

int simple_xattr_remove(struct simple_xattrs *xattrs, const char *name);

ssize_t simple_xattr_list(struct simple_xattrs *xattrs, char *buffer,

			  size_t size);

void simple_xattr_list_add(struct simple_xattrs *xattrs,

			   struct simple_xattr *new_xattr);



#endif  /*  __KERNEL__  */



#endif	/* _LINUX_XATTR_H */

mm/shmem.c

+13 −158
Original line number Diff line number Diff line
@@ -77,13 +77,6 @@ static struct vfsmount *shm_mnt; 
/* Symlink up to this size is kmalloc'ed instead of using a swappable page */

#define SHORT_SYMLINK_LEN 128



struct shmem_xattr {

	struct list_head list;	/* anchored by shmem_inode_info->xattr_list */

	char *name;		/* xattr name */

	size_t size;

	char value[0];

};



/*

 * shmem_fallocate and shmem_writepage communicate via inode->i_private

 * (with i_mutex making sure that it has only one user at a time):
@@ -636,7 +629,6 @@ static int shmem_setattr(struct dentry *dentry, struct iattr *attr) 
static void shmem_evict_inode(struct inode *inode)

{

	struct shmem_inode_info *info = SHMEM_I(inode);

	struct shmem_xattr *xattr, *nxattr;



	if (inode->i_mapping->a_ops == &shmem_aops) {

		shmem_unacct_size(info->flags, inode->i_size);
@@ -650,10 +642,7 @@ static void shmem_evict_inode(struct inode *inode) 
	} else

		kfree(info->symlink);



	list_for_each_entry_safe(xattr, nxattr, &info->xattr_list, list) {

		kfree(xattr->name);

		kfree(xattr);

	}

	simple_xattrs_free(&info->xattrs);

	BUG_ON(inode->i_blocks);

	shmem_free_inode(inode->i_sb);

	clear_inode(inode);
@@ -1377,7 +1366,7 @@ static struct inode *shmem_get_inode(struct super_block *sb, const struct inode 
		spin_lock_init(&info->lock);

		info->flags = flags & VM_NORESERVE;

		INIT_LIST_HEAD(&info->swaplist);

		INIT_LIST_HEAD(&info->xattr_list);

		simple_xattrs_init(&info->xattrs);

		cache_no_acl(inode);



		switch (mode & S_IFMT) {
@@ -2059,28 +2048,6 @@ static void shmem_put_link(struct dentry *dentry, struct nameidata *nd, void *co 
 * filesystem level, though.

 */



/*

 * Allocate new xattr and copy in the value; but leave the name to callers.

 */

static struct shmem_xattr *shmem_xattr_alloc(const void *value, size_t size)

{

	struct shmem_xattr *new_xattr;

	size_t len;



	/* wrap around? */

	len = sizeof(*new_xattr) + size;

	if (len <= sizeof(*new_xattr))

		return NULL;



	new_xattr = kmalloc(len, GFP_KERNEL);

	if (!new_xattr)

		return NULL;



	new_xattr->size = size;

	memcpy(new_xattr->value, value, size);

	return new_xattr;

}



/*

 * Callback for security_inode_init_security() for acquiring xattrs.

 */
@@ -2090,11 +2057,11 @@ static int shmem_initxattrs(struct inode *inode, 
{

	struct shmem_inode_info *info = SHMEM_I(inode);

	const struct xattr *xattr;

	struct shmem_xattr *new_xattr;

	struct simple_xattr *new_xattr;

	size_t len;



	for (xattr = xattr_array; xattr->name != NULL; xattr++) {

		new_xattr = shmem_xattr_alloc(xattr->value, xattr->value_len);

		new_xattr = simple_xattr_alloc(xattr->value, xattr->value_len);

		if (!new_xattr)

			return -ENOMEM;
@@ -2111,91 +2078,12 @@ static int shmem_initxattrs(struct inode *inode, 
		memcpy(new_xattr->name + XATTR_SECURITY_PREFIX_LEN,

		       xattr->name, len);



		spin_lock(&info->lock);

		list_add(&new_xattr->list, &info->xattr_list);

		spin_unlock(&info->lock);

		simple_xattr_list_add(&info->xattrs, new_xattr);

	}



	return 0;

}



static int shmem_xattr_get(struct dentry *dentry, const char *name,

			   void *buffer, size_t size)

{

	struct shmem_inode_info *info;

	struct shmem_xattr *xattr;

	int ret = -ENODATA;



	info = SHMEM_I(dentry->d_inode);



	spin_lock(&info->lock);

	list_for_each_entry(xattr, &info->xattr_list, list) {

		if (strcmp(name, xattr->name))

			continue;



		ret = xattr->size;

		if (buffer) {

			if (size < xattr->size)

				ret = -ERANGE;

			else

				memcpy(buffer, xattr->value, xattr->size);

		}

		break;

	}

	spin_unlock(&info->lock);

	return ret;

}



static int shmem_xattr_set(struct inode *inode, const char *name,

			   const void *value, size_t size, int flags)

{

	struct shmem_inode_info *info = SHMEM_I(inode);

	struct shmem_xattr *xattr;

	struct shmem_xattr *new_xattr = NULL;

	int err = 0;



	/* value == NULL means remove */

	if (value) {

		new_xattr = shmem_xattr_alloc(value, size);

		if (!new_xattr)

			return -ENOMEM;



		new_xattr->name = kstrdup(name, GFP_KERNEL);

		if (!new_xattr->name) {

			kfree(new_xattr);

			return -ENOMEM;

		}

	}



	spin_lock(&info->lock);

	list_for_each_entry(xattr, &info->xattr_list, list) {

		if (!strcmp(name, xattr->name)) {

			if (flags & XATTR_CREATE) {

				xattr = new_xattr;

				err = -EEXIST;

			} else if (new_xattr) {

				list_replace(&xattr->list, &new_xattr->list);

			} else {

				list_del(&xattr->list);

			}

			goto out;

		}

	}

	if (flags & XATTR_REPLACE) {

		xattr = new_xattr;

		err = -ENODATA;

	} else {

		list_add(&new_xattr->list, &info->xattr_list);

		xattr = NULL;

	}

out:

	spin_unlock(&info->lock);

	if (xattr)

		kfree(xattr->name);

	kfree(xattr);

	return err;

}



static const struct xattr_handler *shmem_xattr_handlers[] = {

#ifdef CONFIG_TMPFS_POSIX_ACL

	&generic_acl_access_handler,
@@ -2226,6 +2114,7 @@ static int shmem_xattr_validate(const char *name) 
static ssize_t shmem_getxattr(struct dentry *dentry, const char *name,

			      void *buffer, size_t size)

{

	struct shmem_inode_info *info = SHMEM_I(dentry->d_inode);

	int err;



	/*
@@ -2240,12 +2129,13 @@ static ssize_t shmem_getxattr(struct dentry *dentry, const char *name, 
	if (err)

		return err;



	return shmem_xattr_get(dentry, name, buffer, size);

	return simple_xattr_get(&info->xattrs, name, buffer, size);

}



static int shmem_setxattr(struct dentry *dentry, const char *name,

			  const void *value, size_t size, int flags)

{

	struct shmem_inode_info *info = SHMEM_I(dentry->d_inode);

	int err;



	/*
@@ -2260,15 +2150,12 @@ static int shmem_setxattr(struct dentry *dentry, const char *name, 
	if (err)

		return err;



	if (size == 0)

		value = "";  /* empty EA, do not remove */



	return shmem_xattr_set(dentry->d_inode, name, value, size, flags);



	return simple_xattr_set(&info->xattrs, name, value, size, flags);

}



static int shmem_removexattr(struct dentry *dentry, const char *name)

{

	struct shmem_inode_info *info = SHMEM_I(dentry->d_inode);

	int err;



	/*
@@ -2283,45 +2170,13 @@ static int shmem_removexattr(struct dentry *dentry, const char *name) 
	if (err)

		return err;



	return shmem_xattr_set(dentry->d_inode, name, NULL, 0, XATTR_REPLACE);

}



static bool xattr_is_trusted(const char *name)

{

	return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);

	return simple_xattr_remove(&info->xattrs, name);

}



static ssize_t shmem_listxattr(struct dentry *dentry, char *buffer, size_t size)

{

	bool trusted = capable(CAP_SYS_ADMIN);

	struct shmem_xattr *xattr;

	struct shmem_inode_info *info;

	size_t used = 0;



	info = SHMEM_I(dentry->d_inode);



	spin_lock(&info->lock);

	list_for_each_entry(xattr, &info->xattr_list, list) {

		size_t len;



		/* skip "trusted." attributes for unprivileged callers */

		if (!trusted && xattr_is_trusted(xattr->name))

			continue;



		len = strlen(xattr->name) + 1;

		used += len;

		if (buffer) {

			if (size < used) {

				used = -ERANGE;

				break;

			}

			memcpy(buffer, xattr->name, len);

			buffer += len;

		}

	}

	spin_unlock(&info->lock);



	return used;

	struct shmem_inode_info *info = SHMEM_I(dentry->d_inode);

	return simple_xattr_list(&info->xattrs, buffer, size);

}

#endif /* CONFIG_TMPFS_XATTR */