diff mbox

[v23,18/22] richacl: xattr mapping functions

Message ID 1467294433-3222-19-git-send-email-agruenba@redhat.com (mailing list archive)
State New, archived
Headers show

Commit Message

Andreas Gruenbacher June 30, 2016, 1:47 p.m. UTC
Map between "system.richacl" xattrs and the in-kernel representation.

Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
---
 fs/Makefile                        |   2 +-
 fs/richacl_xattr.c                 | 161 +++++++++++++++++++++++++++++++++++++
 include/linux/richacl_xattr.h      |  29 +++++++
 include/uapi/linux/Kbuild          |   1 +
 include/uapi/linux/richacl_xattr.h |  44 ++++++++++
 include/uapi/linux/xattr.h         |   2 +
 6 files changed, 238 insertions(+), 1 deletion(-)
 create mode 100644 fs/richacl_xattr.c
 create mode 100644 include/linux/richacl_xattr.h
 create mode 100644 include/uapi/linux/richacl_xattr.h

Comments

Jeff Layton July 12, 2016, 12:02 p.m. UTC | #1
On Thu, 2016-06-30 at 15:47 +0200, Andreas Gruenbacher wrote:
> Map between "system.richacl" xattrs and the in-kernel representation.
> 
> Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
> ---
>  fs/Makefile                        |   2 +-
>  fs/richacl_xattr.c                 | 161 +++++++++++++++++++++++++++++++++++++
>  include/linux/richacl_xattr.h      |  29 +++++++
>  include/uapi/linux/Kbuild          |   1 +
>  include/uapi/linux/richacl_xattr.h |  44 ++++++++++
>  include/uapi/linux/xattr.h         |   2 +
>  6 files changed, 238 insertions(+), 1 deletion(-)
>  create mode 100644 fs/richacl_xattr.c
>  create mode 100644 include/linux/richacl_xattr.h
>  create mode 100644 include/uapi/linux/richacl_xattr.h
> 
> diff --git a/fs/Makefile b/fs/Makefile
> index 2b3e6f1..262fd67 100644
> --- a/fs/Makefile
> +++ b/fs/Makefile
> @@ -49,7 +49,7 @@ obj-$(CONFIG_COREDUMP)		+= coredump.o
>  obj-$(CONFIG_SYSCTL)		+= drop_caches.o
>  
>  obj-$(CONFIG_FHANDLE)		+= fhandle.o
> -obj-$(CONFIG_FS_RICHACL)	+= richacl.o
> +obj-$(CONFIG_FS_RICHACL)	+= richacl.o richacl_xattr.o
>  
>  obj-y				+= quota/
>  
> diff --git a/fs/richacl_xattr.c b/fs/richacl_xattr.c
> new file mode 100644
> index 0000000..dc1ad36
> --- /dev/null
> +++ b/fs/richacl_xattr.c
> @@ -0,0 +1,161 @@
> +/*
> + * Copyright (C) 2006, 2010  Novell, Inc.
> + * Copyright (C) 2015  Red Hat, Inc.
> + * Written by Andreas Gruenbacher <agruenba@redhat.com>
> + *
> + * This program is free software; you can redistribute it and/or modify it
> + * under the terms of the GNU General Public License as published by the
> + * Free Software Foundation; either version 2, or (at your option) any
> + * later version.
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> + * General Public License for more details.
> + */
> +
> +#include 
> +#include 
> +#include 
> +#include 
> +#include 
> +
> +/**
> + * richacl_from_xattr  -  convert a richacl xattr into the in-memory representation
> + */
> +struct richacl *
> +richacl_from_xattr(struct user_namespace *user_ns,
> +		   const void *value, size_t size, int invalid_error)
> +{
> +	const struct richacl_xattr *xattr_acl = value;
> +	const struct richace_xattr *xattr_ace = (void *)(xattr_acl + 1);
> +	struct richacl *acl;
> +	struct richace *ace;
> +	int count;
> +
> +	if (size < sizeof(*xattr_acl) ||
> +	    xattr_acl->a_version != RICHACL_XATTR_VERSION ||
> +	    (xattr_acl->a_flags & ~RICHACL_VALID_FLAGS))
> +		goto invalid;
> +	size -= sizeof(*xattr_acl);
> +	count = le16_to_cpu(xattr_acl->a_count);
> +	if (count > RICHACL_XATTR_MAX_COUNT)
> +		goto invalid;
> +	if (size != count * sizeof(*xattr_ace))
> +		goto invalid;
> +
> +	acl = richacl_alloc(count, GFP_NOFS);
> +	if (!acl)
> +		return ERR_PTR(-ENOMEM);
> +
> +	acl->a_flags = xattr_acl->a_flags;
> +	acl->a_owner_mask = le32_to_cpu(xattr_acl->a_owner_mask);
> +	if (acl->a_owner_mask & ~RICHACE_VALID_MASK)
> +		goto put_invalid;
> +	acl->a_group_mask = le32_to_cpu(xattr_acl->a_group_mask);
> +	if (acl->a_group_mask & ~RICHACE_VALID_MASK)
> +		goto put_invalid;
> +	acl->a_other_mask = le32_to_cpu(xattr_acl->a_other_mask);
> +	if (acl->a_other_mask & ~RICHACE_VALID_MASK)
> +		goto put_invalid;
> +
> +	richacl_for_each_entry(ace, acl) {
> +		ace->e_type  = le16_to_cpu(xattr_ace->e_type);
> +		ace->e_flags = le16_to_cpu(xattr_ace->e_flags);
> +		ace->e_mask  = le32_to_cpu(xattr_ace->e_mask);
> +
> +		if (ace->e_flags & ~RICHACE_VALID_FLAGS)
> +			goto put_invalid;
> +		if (ace->e_flags & RICHACE_SPECIAL_WHO) {
> +			ace->e_id.special = le32_to_cpu(xattr_ace->e_id);
> +			if (ace->e_id.special > RICHACE_EVERYONE_SPECIAL_ID)
> +				goto put_invalid;
> +		} else if (ace->e_flags & RICHACE_IDENTIFIER_GROUP) {
> +			u32 id = le32_to_cpu(xattr_ace->e_id);
> +
> +			ace->e_id.gid = make_kgid(user_ns, id);
> +			if (!gid_valid(ace->e_id.gid))
> +				goto put_invalid;
> +		} else {
> +			u32 id = le32_to_cpu(xattr_ace->e_id);
> +
> +			ace->e_id.uid = make_kuid(user_ns, id);
> +			if (!uid_valid(ace->e_id.uid))
> +				goto put_invalid;
> +		}
> +		if (ace->e_type > RICHACE_ACCESS_DENIED_ACE_TYPE ||
> +		    (ace->e_mask & ~RICHACE_VALID_MASK))
> +			goto put_invalid;
> +
> +		xattr_ace++;
> +	}
> +
> +	return acl;
> +
> +put_invalid:
> +	richacl_put(acl);
> +invalid:
> +	return ERR_PTR(invalid_error);
> +}
> +EXPORT_SYMBOL_GPL(richacl_from_xattr);
> +
> +/**
> + * richacl_xattr_size  -  compute the size of the xattr representation of @acl
> + */
> +size_t
> +richacl_xattr_size(const struct richacl *acl)
> +{
> +	size_t size = sizeof(struct richacl_xattr);
> +
> +	size += sizeof(struct richace_xattr) * acl->a_count;
> +	return size;
> +}
> +EXPORT_SYMBOL_GPL(richacl_xattr_size);
> +
> +/**
> + * richacl_to_xattr  -  convert @acl into its xattr representation
> + * @acl:	the richacl to convert
> + * @buffer:	buffer for the result
> + * @size:	size of @buffer
> + */
> +int
> +richacl_to_xattr(struct user_namespace *user_ns,
> +		 const struct richacl *acl, void *buffer, size_t size)
> +{
> +	struct richacl_xattr *xattr_acl = buffer;
> +	struct richace_xattr *xattr_ace;
> +	const struct richace *ace;
> +	size_t real_size;
> +
> +	real_size = richacl_xattr_size(acl);
> +	if (!buffer)
> +		return real_size;
> +	if (real_size > size)
> +		return -ERANGE;
> +
> +	xattr_acl->a_version = RICHACL_XATTR_VERSION;
> +	xattr_acl->a_flags = acl->a_flags;
> +	xattr_acl->a_count = cpu_to_le16(acl->a_count);
> +
> +	xattr_acl->a_owner_mask = cpu_to_le32(acl->a_owner_mask);
> +	xattr_acl->a_group_mask = cpu_to_le32(acl->a_group_mask);
> +	xattr_acl->a_other_mask = cpu_to_le32(acl->a_other_mask);
> +
> +	xattr_ace = (void *)(xattr_acl + 1);
> +	richacl_for_each_entry(ace, acl) {
> +		xattr_ace->e_type = cpu_to_le16(ace->e_type);
> +		xattr_ace->e_flags = cpu_to_le16(ace->e_flags);
> +		xattr_ace->e_mask = cpu_to_le32(ace->e_mask);
> +		if (ace->e_flags & RICHACE_SPECIAL_WHO)
> +			xattr_ace->e_id = cpu_to_le32(ace->e_id.special);
> +		else if (ace->e_flags & RICHACE_IDENTIFIER_GROUP)
> +			xattr_ace->e_id =
> +				cpu_to_le32(from_kgid(user_ns, ace->e_id.gid));
> +		else
> +			xattr_ace->e_id =
> +				cpu_to_le32(from_kuid(user_ns, ace->e_id.uid));
> +		xattr_ace++;
> +	}
> +	return real_size;
> +}
> +EXPORT_SYMBOL_GPL(richacl_to_xattr);
> diff --git a/include/linux/richacl_xattr.h b/include/linux/richacl_xattr.h
> new file mode 100644
> index 0000000..0efa14b
> --- /dev/null
> +++ b/include/linux/richacl_xattr.h
> @@ -0,0 +1,29 @@
> +/*
> + * Copyright (C) 2006, 2010  Novell, Inc.
> + * Copyright (C) 2015  Red Hat, Inc.
> + * Written by Andreas Gruenbacher <agruenba@redhat.com>
> + *
> + * This program is free software; you can redistribute it and/or modify it
> + * under the terms of the GNU General Public License as published by the
> + * Free Software Foundation; either version 2, or (at your option) any
> + * later version.
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> + * General Public License for more details.
> + */
> +
> +#ifndef __RICHACL_XATTR_H
> +#define __RICHACL_XATTR_H
> +
> +#include 
> +#include 
> +
> +extern struct richacl *richacl_from_xattr(struct user_namespace *, const void *,
> +					  size_t, int);
> +extern size_t richacl_xattr_size(const struct richacl *);
> +extern int richacl_to_xattr(struct user_namespace *, const struct richacl *,
> +			    void *, size_t);
> +
> +#endif /* __RICHACL_XATTR_H */
> diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild
> index abeaa98..c24e106 100644
> --- a/include/uapi/linux/Kbuild
> +++ b/include/uapi/linux/Kbuild
> @@ -356,6 +356,7 @@ header-y += reiserfs_fs.h
>  header-y += reiserfs_xattr.h
>  header-y += resource.h
>  header-y += richacl.h
> +header-y += richacl_xattr.h
>  header-y += rfkill.h
>  header-y += rio_mport_cdev.h
>  header-y += romfs_fs.h
> diff --git a/include/uapi/linux/richacl_xattr.h b/include/uapi/linux/richacl_xattr.h
> new file mode 100644
> index 0000000..20da204
> --- /dev/null
> +++ b/include/uapi/linux/richacl_xattr.h
> @@ -0,0 +1,44 @@
> +/*
> + * Copyright (C) 2006, 2010  Novell, Inc.
> + * Copyright (C) 2015  Red Hat, Inc.
> + * Written by Andreas Gruenbacher <agruenba@redhat.com>
> + *
> + * This file is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; either
> + * version 2.1 of the License, or (at your option) any later version.
> + *
> + * This file is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> + * Lesser General Public License for more details.
> + */
> +
> +#ifndef __UAPI_RICHACL_XATTR_H
> +#define __UAPI_RICHACL_XATTR_H
> +
> +#include 
> +#include 
> +
> +struct richace_xattr {
> +	__le16	e_type;
> +	__le16	e_flags;
> +	__le32	e_mask;
> +	__le32	e_id;
> +};
> +
> +struct richacl_xattr {
> +	__u8	a_version;
> +	__u8	a_flags;
> +	__le16	a_count;
> +	__le32	a_owner_mask;
> +	__le32	a_group_mask;
> +	__le32	a_other_mask;
> +};
> +
> +#define RICHACL_XATTR_VERSION 0
> +#define RICHACL_XATTR_MAX_COUNT \
> +	((XATTR_SIZE_MAX - sizeof(struct richacl_xattr)) / \
> +	 sizeof(struct richace_xattr))
> +
> +#endif  /* __UAPI_RICHACL_XATTR_H */
> diff --git a/include/uapi/linux/xattr.h b/include/uapi/linux/xattr.h
> index 1590c49..1996903 100644
> --- a/include/uapi/linux/xattr.h
> +++ b/include/uapi/linux/xattr.h
> @@ -73,5 +73,7 @@
>  #define XATTR_POSIX_ACL_DEFAULT  "posix_acl_default"
>  #define XATTR_NAME_POSIX_ACL_DEFAULT XATTR_SYSTEM_PREFIX XATTR_POSIX_ACL_DEFAULT
>  
> +#define XATTR_RICHACL "richacl"
> +#define XATTR_NAME_RICHACL XATTR_SYSTEM_PREFIX XATTR_RICHACL
>  
>  #endif /* _UAPI_LINUX_XATTR_H */

Fair enough. I do wonder a bit whether we might be better served with a
new set of syscalls for this instead of using xattrs (as I think
Christoph has suggested). What _is_ the rationale for doing this with
xattrs, btw?

Regardless, this patch looks fine to me, assuming that we really do
want to do this xattrs:

Reviewed-by: Jeff Layton <jlayton@redhat.com>
--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Andreas Gruenbacher July 14, 2016, 8:33 p.m. UTC | #2
On Tue, Jul 12, 2016 at 2:02 PM, Jeff Layton <jlayton@redhat.com> wrote:
> On Thu, 2016-06-30 at 15:47 +0200, Andreas Gruenbacher wrote:
>> Map between "system.richacl" xattrs and the in-kernel representation.
>>
>> Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
>> ---
>>  fs/Makefile                        |   2 +-
>>  fs/richacl_xattr.c                 | 161 +++++++++++++++++++++++++++++++++++++
>>  include/linux/richacl_xattr.h      |  29 +++++++
>>  include/uapi/linux/Kbuild          |   1 +
>>  include/uapi/linux/richacl_xattr.h |  44 ++++++++++
>>  include/uapi/linux/xattr.h         |   2 +
>>  6 files changed, 238 insertions(+), 1 deletion(-)
>>  create mode 100644 fs/richacl_xattr.c
>>  create mode 100644 include/linux/richacl_xattr.h
>>  create mode 100644 include/uapi/linux/richacl_xattr.h
>>
>> diff --git a/fs/Makefile b/fs/Makefile
>> index 2b3e6f1..262fd67 100644
>> --- a/fs/Makefile
>> +++ b/fs/Makefile
>> @@ -49,7 +49,7 @@ obj-$(CONFIG_COREDUMP)              += coredump.o
>>  obj-$(CONFIG_SYSCTL)         += drop_caches.o
>>
>>  obj-$(CONFIG_FHANDLE)                += fhandle.o
>> -obj-$(CONFIG_FS_RICHACL)     += richacl.o
>> +obj-$(CONFIG_FS_RICHACL)     += richacl.o richacl_xattr.o
>>
>>  obj-y                                += quota/
>>
>> diff --git a/fs/richacl_xattr.c b/fs/richacl_xattr.c
>> new file mode 100644
>> index 0000000..dc1ad36
>> --- /dev/null
>> +++ b/fs/richacl_xattr.c
>> @@ -0,0 +1,161 @@
>> +/*
>> + * Copyright (C) 2006, 2010  Novell, Inc.
>> + * Copyright (C) 2015  Red Hat, Inc.
>> + * Written by Andreas Gruenbacher <agruenba@redhat.com>
>> + *
>> + * This program is free software; you can redistribute it and/or modify it
>> + * under the terms of the GNU General Public License as published by the
>> + * Free Software Foundation; either version 2, or (at your option) any
>> + * later version.
>> + *
>> + * This program is distributed in the hope that it will be useful, but
>> + * WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>> + * General Public License for more details.
>> + */
>> +
>> +#include
>> +#include
>> +#include
>> +#include
>> +#include
>> +
>> +/**
>> + * richacl_from_xattr  -  convert a richacl xattr into the in-memory representation
>> + */
>> +struct richacl *
>> +richacl_from_xattr(struct user_namespace *user_ns,
>> +                const void *value, size_t size, int invalid_error)
>> +{
>> +     const struct richacl_xattr *xattr_acl = value;
>> +     const struct richace_xattr *xattr_ace = (void *)(xattr_acl + 1);
>> +     struct richacl *acl;
>> +     struct richace *ace;
>> +     int count;
>> +
>> +     if (size < sizeof(*xattr_acl) ||
>> +         xattr_acl->a_version != RICHACL_XATTR_VERSION ||
>> +         (xattr_acl->a_flags & ~RICHACL_VALID_FLAGS))
>> +             goto invalid;
>> +     size -= sizeof(*xattr_acl);
>> +     count = le16_to_cpu(xattr_acl->a_count);
>> +     if (count > RICHACL_XATTR_MAX_COUNT)
>> +             goto invalid;
>> +     if (size != count * sizeof(*xattr_ace))
>> +             goto invalid;
>> +
>> +     acl = richacl_alloc(count, GFP_NOFS);
>> +     if (!acl)
>> +             return ERR_PTR(-ENOMEM);
>> +
>> +     acl->a_flags = xattr_acl->a_flags;
>> +     acl->a_owner_mask = le32_to_cpu(xattr_acl->a_owner_mask);
>> +     if (acl->a_owner_mask & ~RICHACE_VALID_MASK)
>> +             goto put_invalid;
>> +     acl->a_group_mask = le32_to_cpu(xattr_acl->a_group_mask);
>> +     if (acl->a_group_mask & ~RICHACE_VALID_MASK)
>> +             goto put_invalid;
>> +     acl->a_other_mask = le32_to_cpu(xattr_acl->a_other_mask);
>> +     if (acl->a_other_mask & ~RICHACE_VALID_MASK)
>> +             goto put_invalid;
>> +
>> +     richacl_for_each_entry(ace, acl) {
>> +             ace->e_type  = le16_to_cpu(xattr_ace->e_type);
>> +             ace->e_flags = le16_to_cpu(xattr_ace->e_flags);
>> +             ace->e_mask  = le32_to_cpu(xattr_ace->e_mask);
>> +
>> +             if (ace->e_flags & ~RICHACE_VALID_FLAGS)
>> +                     goto put_invalid;
>> +             if (ace->e_flags & RICHACE_SPECIAL_WHO) {
>> +                     ace->e_id.special = le32_to_cpu(xattr_ace->e_id);
>> +                     if (ace->e_id.special > RICHACE_EVERYONE_SPECIAL_ID)
>> +                             goto put_invalid;
>> +             } else if (ace->e_flags & RICHACE_IDENTIFIER_GROUP) {
>> +                     u32 id = le32_to_cpu(xattr_ace->e_id);
>> +
>> +                     ace->e_id.gid = make_kgid(user_ns, id);
>> +                     if (!gid_valid(ace->e_id.gid))
>> +                             goto put_invalid;
>> +             } else {
>> +                     u32 id = le32_to_cpu(xattr_ace->e_id);
>> +
>> +                     ace->e_id.uid = make_kuid(user_ns, id);
>> +                     if (!uid_valid(ace->e_id.uid))
>> +                             goto put_invalid;
>> +             }
>> +             if (ace->e_type > RICHACE_ACCESS_DENIED_ACE_TYPE ||
>> +                 (ace->e_mask & ~RICHACE_VALID_MASK))
>> +                     goto put_invalid;
>> +
>> +             xattr_ace++;
>> +     }
>> +
>> +     return acl;
>> +
>> +put_invalid:
>> +     richacl_put(acl);
>> +invalid:
>> +     return ERR_PTR(invalid_error);
>> +}
>> +EXPORT_SYMBOL_GPL(richacl_from_xattr);
>> +
>> +/**
>> + * richacl_xattr_size  -  compute the size of the xattr representation of @acl
>> + */
>> +size_t
>> +richacl_xattr_size(const struct richacl *acl)
>> +{
>> +     size_t size = sizeof(struct richacl_xattr);
>> +
>> +     size += sizeof(struct richace_xattr) * acl->a_count;
>> +     return size;
>> +}
>> +EXPORT_SYMBOL_GPL(richacl_xattr_size);
>> +
>> +/**
>> + * richacl_to_xattr  -  convert @acl into its xattr representation
>> + * @acl:     the richacl to convert
>> + * @buffer:  buffer for the result
>> + * @size:    size of @buffer
>> + */
>> +int
>> +richacl_to_xattr(struct user_namespace *user_ns,
>> +              const struct richacl *acl, void *buffer, size_t size)
>> +{
>> +     struct richacl_xattr *xattr_acl = buffer;
>> +     struct richace_xattr *xattr_ace;
>> +     const struct richace *ace;
>> +     size_t real_size;
>> +
>> +     real_size = richacl_xattr_size(acl);
>> +     if (!buffer)
>> +             return real_size;
>> +     if (real_size > size)
>> +             return -ERANGE;
>> +
>> +     xattr_acl->a_version = RICHACL_XATTR_VERSION;
>> +     xattr_acl->a_flags = acl->a_flags;
>> +     xattr_acl->a_count = cpu_to_le16(acl->a_count);
>> +
>> +     xattr_acl->a_owner_mask = cpu_to_le32(acl->a_owner_mask);
>> +     xattr_acl->a_group_mask = cpu_to_le32(acl->a_group_mask);
>> +     xattr_acl->a_other_mask = cpu_to_le32(acl->a_other_mask);
>> +
>> +     xattr_ace = (void *)(xattr_acl + 1);
>> +     richacl_for_each_entry(ace, acl) {
>> +             xattr_ace->e_type = cpu_to_le16(ace->e_type);
>> +             xattr_ace->e_flags = cpu_to_le16(ace->e_flags);
>> +             xattr_ace->e_mask = cpu_to_le32(ace->e_mask);
>> +             if (ace->e_flags & RICHACE_SPECIAL_WHO)
>> +                     xattr_ace->e_id = cpu_to_le32(ace->e_id.special);
>> +             else if (ace->e_flags & RICHACE_IDENTIFIER_GROUP)
>> +                     xattr_ace->e_id =
>> +                             cpu_to_le32(from_kgid(user_ns, ace->e_id.gid));
>> +             else
>> +                     xattr_ace->e_id =
>> +                             cpu_to_le32(from_kuid(user_ns, ace->e_id.uid));
>> +             xattr_ace++;
>> +     }
>> +     return real_size;
>> +}
>> +EXPORT_SYMBOL_GPL(richacl_to_xattr);
>> diff --git a/include/linux/richacl_xattr.h b/include/linux/richacl_xattr.h
>> new file mode 100644
>> index 0000000..0efa14b
>> --- /dev/null
>> +++ b/include/linux/richacl_xattr.h
>> @@ -0,0 +1,29 @@
>> +/*
>> + * Copyright (C) 2006, 2010  Novell, Inc.
>> + * Copyright (C) 2015  Red Hat, Inc.
>> + * Written by Andreas Gruenbacher <agruenba@redhat.com>
>> + *
>> + * This program is free software; you can redistribute it and/or modify it
>> + * under the terms of the GNU General Public License as published by the
>> + * Free Software Foundation; either version 2, or (at your option) any
>> + * later version.
>> + *
>> + * This program is distributed in the hope that it will be useful, but
>> + * WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>> + * General Public License for more details.
>> + */
>> +
>> +#ifndef __RICHACL_XATTR_H
>> +#define __RICHACL_XATTR_H
>> +
>> +#include
>> +#include
>> +
>> +extern struct richacl *richacl_from_xattr(struct user_namespace *, const void *,
>> +                                       size_t, int);
>> +extern size_t richacl_xattr_size(const struct richacl *);
>> +extern int richacl_to_xattr(struct user_namespace *, const struct richacl *,
>> +                         void *, size_t);
>> +
>> +#endif /* __RICHACL_XATTR_H */
>> diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild
>> index abeaa98..c24e106 100644
>> --- a/include/uapi/linux/Kbuild
>> +++ b/include/uapi/linux/Kbuild
>> @@ -356,6 +356,7 @@ header-y += reiserfs_fs.h
>>  header-y += reiserfs_xattr.h
>>  header-y += resource.h
>>  header-y += richacl.h
>> +header-y += richacl_xattr.h
>>  header-y += rfkill.h
>>  header-y += rio_mport_cdev.h
>>  header-y += romfs_fs.h
>> diff --git a/include/uapi/linux/richacl_xattr.h b/include/uapi/linux/richacl_xattr.h
>> new file mode 100644
>> index 0000000..20da204
>> --- /dev/null
>> +++ b/include/uapi/linux/richacl_xattr.h
>> @@ -0,0 +1,44 @@
>> +/*
>> + * Copyright (C) 2006, 2010  Novell, Inc.
>> + * Copyright (C) 2015  Red Hat, Inc.
>> + * Written by Andreas Gruenbacher <agruenba@redhat.com>
>> + *
>> + * This file is free software; you can redistribute it and/or
>> + * modify it under the terms of the GNU Lesser General Public
>> + * License as published by the Free Software Foundation; either
>> + * version 2.1 of the License, or (at your option) any later version.
>> + *
>> + * This file is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>> + * Lesser General Public License for more details.
>> + */
>> +
>> +#ifndef __UAPI_RICHACL_XATTR_H
>> +#define __UAPI_RICHACL_XATTR_H
>> +
>> +#include
>> +#include
>> +
>> +struct richace_xattr {
>> +     __le16  e_type;
>> +     __le16  e_flags;
>> +     __le32  e_mask;
>> +     __le32  e_id;
>> +};
>> +
>> +struct richacl_xattr {
>> +     __u8    a_version;
>> +     __u8    a_flags;
>> +     __le16  a_count;
>> +     __le32  a_owner_mask;
>> +     __le32  a_group_mask;
>> +     __le32  a_other_mask;
>> +};
>> +
>> +#define RICHACL_XATTR_VERSION 0
>> +#define RICHACL_XATTR_MAX_COUNT \
>> +     ((XATTR_SIZE_MAX - sizeof(struct richacl_xattr)) / \
>> +      sizeof(struct richace_xattr))
>> +
>> +#endif  /* __UAPI_RICHACL_XATTR_H */
>> diff --git a/include/uapi/linux/xattr.h b/include/uapi/linux/xattr.h
>> index 1590c49..1996903 100644
>> --- a/include/uapi/linux/xattr.h
>> +++ b/include/uapi/linux/xattr.h
>> @@ -73,5 +73,7 @@
>>  #define XATTR_POSIX_ACL_DEFAULT  "posix_acl_default"
>>  #define XATTR_NAME_POSIX_ACL_DEFAULT XATTR_SYSTEM_PREFIX XATTR_POSIX_ACL_DEFAULT
>>
>> +#define XATTR_RICHACL "richacl"
>> +#define XATTR_NAME_RICHACL XATTR_SYSTEM_PREFIX XATTR_RICHACL
>>
>>  #endif /* _UAPI_LINUX_XATTR_H */
>
> Fair enough. I do wonder a bit whether we might be better served with a
> new set of syscalls for this instead of using xattrs (as I think
> Christoph has suggested). What _is_ the rationale for doing this with
> xattrs, btw?

Xattrs are intended for exactly this kind of auxiliary file
information. They are used for POSIX ACLs as well, and they are not
going to go away. A number of utilities now include support for
xattrs. By using xattrs for Richacls, those tools will automatically
have at least basic Richacl support (for backup/restore and similar
purposes, for example). In the kernel, supporting a new set of xattrs
is pretty cheap and easy. So I really don't see the point of inventing
yet another interface for basically the same type of information.

> Regardless, this patch looks fine to me, assuming that we really do
> want to do this xattrs:
>
> Reviewed-by: Jeff Layton <jlayton@redhat.com>

Thanks,
Andreas
--
To unsubscribe from this list: send the line "unsubscribe linux-cifs" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
diff mbox

Patch

diff --git a/fs/Makefile b/fs/Makefile
index 2b3e6f1..262fd67 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -49,7 +49,7 @@  obj-$(CONFIG_COREDUMP)		+= coredump.o
 obj-$(CONFIG_SYSCTL)		+= drop_caches.o
 
 obj-$(CONFIG_FHANDLE)		+= fhandle.o
-obj-$(CONFIG_FS_RICHACL)	+= richacl.o
+obj-$(CONFIG_FS_RICHACL)	+= richacl.o richacl_xattr.o
 
 obj-y				+= quota/
 
diff --git a/fs/richacl_xattr.c b/fs/richacl_xattr.c
new file mode 100644
index 0000000..dc1ad36
--- /dev/null
+++ b/fs/richacl_xattr.c
@@ -0,0 +1,161 @@ 
+/*
+ * Copyright (C) 2006, 2010  Novell, Inc.
+ * Copyright (C) 2015  Red Hat, Inc.
+ * Written by Andreas Gruenbacher <agruenba@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#include <linux/sched.h>
+#include <linux/fs.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/richacl_xattr.h>
+
+/**
+ * richacl_from_xattr  -  convert a richacl xattr into the in-memory representation
+ */
+struct richacl *
+richacl_from_xattr(struct user_namespace *user_ns,
+		   const void *value, size_t size, int invalid_error)
+{
+	const struct richacl_xattr *xattr_acl = value;
+	const struct richace_xattr *xattr_ace = (void *)(xattr_acl + 1);
+	struct richacl *acl;
+	struct richace *ace;
+	int count;
+
+	if (size < sizeof(*xattr_acl) ||
+	    xattr_acl->a_version != RICHACL_XATTR_VERSION ||
+	    (xattr_acl->a_flags & ~RICHACL_VALID_FLAGS))
+		goto invalid;
+	size -= sizeof(*xattr_acl);
+	count = le16_to_cpu(xattr_acl->a_count);
+	if (count > RICHACL_XATTR_MAX_COUNT)
+		goto invalid;
+	if (size != count * sizeof(*xattr_ace))
+		goto invalid;
+
+	acl = richacl_alloc(count, GFP_NOFS);
+	if (!acl)
+		return ERR_PTR(-ENOMEM);
+
+	acl->a_flags = xattr_acl->a_flags;
+	acl->a_owner_mask = le32_to_cpu(xattr_acl->a_owner_mask);
+	if (acl->a_owner_mask & ~RICHACE_VALID_MASK)
+		goto put_invalid;
+	acl->a_group_mask = le32_to_cpu(xattr_acl->a_group_mask);
+	if (acl->a_group_mask & ~RICHACE_VALID_MASK)
+		goto put_invalid;
+	acl->a_other_mask = le32_to_cpu(xattr_acl->a_other_mask);
+	if (acl->a_other_mask & ~RICHACE_VALID_MASK)
+		goto put_invalid;
+
+	richacl_for_each_entry(ace, acl) {
+		ace->e_type  = le16_to_cpu(xattr_ace->e_type);
+		ace->e_flags = le16_to_cpu(xattr_ace->e_flags);
+		ace->e_mask  = le32_to_cpu(xattr_ace->e_mask);
+
+		if (ace->e_flags & ~RICHACE_VALID_FLAGS)
+			goto put_invalid;
+		if (ace->e_flags & RICHACE_SPECIAL_WHO) {
+			ace->e_id.special = le32_to_cpu(xattr_ace->e_id);
+			if (ace->e_id.special > RICHACE_EVERYONE_SPECIAL_ID)
+				goto put_invalid;
+		} else if (ace->e_flags & RICHACE_IDENTIFIER_GROUP) {
+			u32 id = le32_to_cpu(xattr_ace->e_id);
+
+			ace->e_id.gid = make_kgid(user_ns, id);
+			if (!gid_valid(ace->e_id.gid))
+				goto put_invalid;
+		} else {
+			u32 id = le32_to_cpu(xattr_ace->e_id);
+
+			ace->e_id.uid = make_kuid(user_ns, id);
+			if (!uid_valid(ace->e_id.uid))
+				goto put_invalid;
+		}
+		if (ace->e_type > RICHACE_ACCESS_DENIED_ACE_TYPE ||
+		    (ace->e_mask & ~RICHACE_VALID_MASK))
+			goto put_invalid;
+
+		xattr_ace++;
+	}
+
+	return acl;
+
+put_invalid:
+	richacl_put(acl);
+invalid:
+	return ERR_PTR(invalid_error);
+}
+EXPORT_SYMBOL_GPL(richacl_from_xattr);
+
+/**
+ * richacl_xattr_size  -  compute the size of the xattr representation of @acl
+ */
+size_t
+richacl_xattr_size(const struct richacl *acl)
+{
+	size_t size = sizeof(struct richacl_xattr);
+
+	size += sizeof(struct richace_xattr) * acl->a_count;
+	return size;
+}
+EXPORT_SYMBOL_GPL(richacl_xattr_size);
+
+/**
+ * richacl_to_xattr  -  convert @acl into its xattr representation
+ * @acl:	the richacl to convert
+ * @buffer:	buffer for the result
+ * @size:	size of @buffer
+ */
+int
+richacl_to_xattr(struct user_namespace *user_ns,
+		 const struct richacl *acl, void *buffer, size_t size)
+{
+	struct richacl_xattr *xattr_acl = buffer;
+	struct richace_xattr *xattr_ace;
+	const struct richace *ace;
+	size_t real_size;
+
+	real_size = richacl_xattr_size(acl);
+	if (!buffer)
+		return real_size;
+	if (real_size > size)
+		return -ERANGE;
+
+	xattr_acl->a_version = RICHACL_XATTR_VERSION;
+	xattr_acl->a_flags = acl->a_flags;
+	xattr_acl->a_count = cpu_to_le16(acl->a_count);
+
+	xattr_acl->a_owner_mask = cpu_to_le32(acl->a_owner_mask);
+	xattr_acl->a_group_mask = cpu_to_le32(acl->a_group_mask);
+	xattr_acl->a_other_mask = cpu_to_le32(acl->a_other_mask);
+
+	xattr_ace = (void *)(xattr_acl + 1);
+	richacl_for_each_entry(ace, acl) {
+		xattr_ace->e_type = cpu_to_le16(ace->e_type);
+		xattr_ace->e_flags = cpu_to_le16(ace->e_flags);
+		xattr_ace->e_mask = cpu_to_le32(ace->e_mask);
+		if (ace->e_flags & RICHACE_SPECIAL_WHO)
+			xattr_ace->e_id = cpu_to_le32(ace->e_id.special);
+		else if (ace->e_flags & RICHACE_IDENTIFIER_GROUP)
+			xattr_ace->e_id =
+				cpu_to_le32(from_kgid(user_ns, ace->e_id.gid));
+		else
+			xattr_ace->e_id =
+				cpu_to_le32(from_kuid(user_ns, ace->e_id.uid));
+		xattr_ace++;
+	}
+	return real_size;
+}
+EXPORT_SYMBOL_GPL(richacl_to_xattr);
diff --git a/include/linux/richacl_xattr.h b/include/linux/richacl_xattr.h
new file mode 100644
index 0000000..0efa14b
--- /dev/null
+++ b/include/linux/richacl_xattr.h
@@ -0,0 +1,29 @@ 
+/*
+ * Copyright (C) 2006, 2010  Novell, Inc.
+ * Copyright (C) 2015  Red Hat, Inc.
+ * Written by Andreas Gruenbacher <agruenba@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#ifndef __RICHACL_XATTR_H
+#define __RICHACL_XATTR_H
+
+#include <uapi/linux/richacl_xattr.h>
+#include <linux/richacl.h>
+
+extern struct richacl *richacl_from_xattr(struct user_namespace *, const void *,
+					  size_t, int);
+extern size_t richacl_xattr_size(const struct richacl *);
+extern int richacl_to_xattr(struct user_namespace *, const struct richacl *,
+			    void *, size_t);
+
+#endif /* __RICHACL_XATTR_H */
diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild
index abeaa98..c24e106 100644
--- a/include/uapi/linux/Kbuild
+++ b/include/uapi/linux/Kbuild
@@ -356,6 +356,7 @@  header-y += reiserfs_fs.h
 header-y += reiserfs_xattr.h
 header-y += resource.h
 header-y += richacl.h
+header-y += richacl_xattr.h
 header-y += rfkill.h
 header-y += rio_mport_cdev.h
 header-y += romfs_fs.h
diff --git a/include/uapi/linux/richacl_xattr.h b/include/uapi/linux/richacl_xattr.h
new file mode 100644
index 0000000..20da204
--- /dev/null
+++ b/include/uapi/linux/richacl_xattr.h
@@ -0,0 +1,44 @@ 
+/*
+ * Copyright (C) 2006, 2010  Novell, Inc.
+ * Copyright (C) 2015  Red Hat, Inc.
+ * Written by Andreas Gruenbacher <agruenba@redhat.com>
+ *
+ * This file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This file is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ */
+
+#ifndef __UAPI_RICHACL_XATTR_H
+#define __UAPI_RICHACL_XATTR_H
+
+#include <linux/types.h>
+#include <linux/limits.h>
+
+struct richace_xattr {
+	__le16	e_type;
+	__le16	e_flags;
+	__le32	e_mask;
+	__le32	e_id;
+};
+
+struct richacl_xattr {
+	__u8	a_version;
+	__u8	a_flags;
+	__le16	a_count;
+	__le32	a_owner_mask;
+	__le32	a_group_mask;
+	__le32	a_other_mask;
+};
+
+#define RICHACL_XATTR_VERSION 0
+#define RICHACL_XATTR_MAX_COUNT \
+	((XATTR_SIZE_MAX - sizeof(struct richacl_xattr)) / \
+	 sizeof(struct richace_xattr))
+
+#endif  /* __UAPI_RICHACL_XATTR_H */
diff --git a/include/uapi/linux/xattr.h b/include/uapi/linux/xattr.h
index 1590c49..1996903 100644
--- a/include/uapi/linux/xattr.h
+++ b/include/uapi/linux/xattr.h
@@ -73,5 +73,7 @@ 
 #define XATTR_POSIX_ACL_DEFAULT  "posix_acl_default"
 #define XATTR_NAME_POSIX_ACL_DEFAULT XATTR_SYSTEM_PREFIX XATTR_POSIX_ACL_DEFAULT
 
+#define XATTR_RICHACL "richacl"
+#define XATTR_NAME_RICHACL XATTR_SYSTEM_PREFIX XATTR_RICHACL
 
 #endif /* _UAPI_LINUX_XATTR_H */