| Message ID | 1456733847-17982-22-git-send-email-agruenba@redhat.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
> +static inline int > +ext4_acl_chmod(struct inode *inode, umode_t mode) > +{ > + if (IS_RICHACL(inode)) > + return richacl_chmod(inode, inode->i_mode); > + return posix_acl_chmod(inode, inode->i_mode); > +} Thi isn't ext4-specific and potentially duplicated in every caller. Please provide this as a common helper. Also while we're at it, the mode argument is ignore and the function always uses inode->i_mode instead. > +ext4_get_richacl(struct inode *inode) > +{ > + const int name_index = EXT4_XATTR_INDEX_RICHACL; > + void *value = NULL; > + struct richacl *acl = NULL; > + int retval; > + > + retval = ext4_xattr_get(inode, name_index, "", NULL, 0); > + if (retval > 0) { > + value = kmalloc(retval, GFP_NOFS); > + if (!value) > + return ERR_PTR(-ENOMEM); > + retval = ext4_xattr_get(inode, name_index, "", value, retval); > + } > + if (retval > 0) { > + acl = richacl_from_xattr(&init_user_ns, value, retval); > + if (acl == ERR_PTR(-EINVAL)) > + acl = ERR_PTR(-EIO); Shouldn't richacl_from_xattr return the error pointer that ->get_richacl callers expect? > +static int > +__ext4_set_richacl(handle_t *handle, struct inode *inode, struct richacl *acl) > +{ > + const int name_index = EXT4_XATTR_INDEX_RICHACL; > + umode_t mode = inode->i_mode; > + int retval, size; > + void *value; > + > + if (richacl_equiv_mode(acl, &mode) == 0) { > + inode->i_ctime = ext4_current_time(inode); > + inode->i_mode = mode; > + ext4_mark_inode_dirty(handle, inode); > + return __ext4_remove_richacl(handle, inode); > + } Should this check for a NULL acl instead of special casing that in ext4_set_richacl? > +int > +ext4_init_richacl(handle_t *handle, struct inode *inode, struct inode *dir) > +{ > + struct richacl *acl = richacl_create(&inode->i_mode, dir); > + int error; > + > + error = PTR_ERR(acl); > + if (IS_ERR(acl)) > + return error; if (IS_ERR(acl)) return PTR_ERR(acl); > + if (acl) { > + error = __ext4_set_richacl(handle, inode, acl); > + richacl_put(acl); > + } Shouldn't richacl_create return NULL if the ACL is equivalent to the mode bits instead of letting every filesystem figure that out on it's own? -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Fri, Mar 11, 2016 at 3:27 PM, Christoph Hellwig <hch@infradead.org> wrote: >> +static inline int >> +ext4_acl_chmod(struct inode *inode, umode_t mode) >> +{ >> + if (IS_RICHACL(inode)) >> + return richacl_chmod(inode, inode->i_mode); >> + return posix_acl_chmod(inode, inode->i_mode); >> +} > > Thi isn't ext4-specific and potentially duplicated in every caller. > Please provide this as a common helper. > > Also while we're at it, the mode argument is ignore and the function > always uses inode->i_mode instead. > >> +ext4_get_richacl(struct inode *inode) >> +{ >> + const int name_index = EXT4_XATTR_INDEX_RICHACL; >> + void *value = NULL; >> + struct richacl *acl = NULL; >> + int retval; >> + >> + retval = ext4_xattr_get(inode, name_index, "", NULL, 0); >> + if (retval > 0) { >> + value = kmalloc(retval, GFP_NOFS); >> + if (!value) >> + return ERR_PTR(-ENOMEM); >> + retval = ext4_xattr_get(inode, name_index, "", value, retval); >> + } >> + if (retval > 0) { >> + acl = richacl_from_xattr(&init_user_ns, value, retval); >> + if (acl == ERR_PTR(-EINVAL)) >> + acl = ERR_PTR(-EIO); > > Shouldn't richacl_from_xattr return the error pointer that ->get_richacl > callers expect? The xattr representation is the same on disk and at the xattr syscall layer, and so richacl_from_xattr is used for converting into the in-memory representation in both cases. The error codes are not the same when a user supplies an invalid value via setxattr or NFS and when an invalid xattr is read from disk though. I'll add a parameter to richacl_from_xattr to make this more explicit. >> +static int >> +__ext4_set_richacl(handle_t *handle, struct inode *inode, struct richacl *acl) >> +{ >> + const int name_index = EXT4_XATTR_INDEX_RICHACL; >> + umode_t mode = inode->i_mode; >> + int retval, size; >> + void *value; >> + >> + if (richacl_equiv_mode(acl, &mode) == 0) { >> + inode->i_ctime = ext4_current_time(inode); >> + inode->i_mode = mode; >> + ext4_mark_inode_dirty(handle, inode); >> + return __ext4_remove_richacl(handle, inode); >> + } > > Should this check for a NULL acl instead of special casing that > in ext4_set_richacl? I'm not sure I understand what you mean. When the >> +int >> +ext4_init_richacl(handle_t *handle, struct inode *inode, struct inode *dir) >> +{ >> + struct richacl *acl = richacl_create(&inode->i_mode, dir); >> + int error; >> + >> + error = PTR_ERR(acl); >> + if (IS_ERR(acl)) >> + return error; > > if (IS_ERR(acl)) > return PTR_ERR(acl); > >> + if (acl) { >> + error = __ext4_set_richacl(handle, inode, acl); >> + richacl_put(acl); >> + } > > Shouldn't richacl_create return NULL if the ACL is equivalent to the > mode bits instead of letting every filesystem figure that out on it's > own? > -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Fri, Mar 11, 2016 at 3:27 PM, Christoph Hellwig <hch@infradead.org> wrote: >> +static int >> +__ext4_set_richacl(handle_t *handle, struct inode *inode, struct richacl *acl) >> +{ >> + const int name_index = EXT4_XATTR_INDEX_RICHACL; >> + umode_t mode = inode->i_mode; >> + int retval, size; >> + void *value; >> + >> + if (richacl_equiv_mode(acl, &mode) == 0) { >> + inode->i_ctime = ext4_current_time(inode); >> + inode->i_mode = mode; >> + ext4_mark_inode_dirty(handle, inode); >> + return __ext4_remove_richacl(handle, inode); >> + } > > Should this check for a NULL acl instead of special casing that > in ext4_set_richacl? I'm not sure I understand what you mean. When iop->set_richacl is called with a richacl that is mode-equivalent, the file permission bits need to be updated and any existing acl needs to be removed. Doing this at the vfs level would result in two calls, iop->setattr and iop->set_richacl, which can cause problems. To remove an existing acl without setting the mode, set_richacl is called with a NULL richacl. __ext4_set_richacl() was split into __ext4_set_richacl() and __ext4_remove_richacl() to align with the xfs code due to the following comment from Dave Chinner: http://oss.sgi.com/archives/xfs/2015-10/msg00354.html Diff here: https://git.kernel.org/cgit/linux/kernel/git/agruen/linux-richacl.git/diff/fs/ext4/richacl.c?id=richacl-2015-10-16&id2=richacl-2015-10-12 >> +int >> +ext4_init_richacl(handle_t *handle, struct inode *inode, struct inode *dir) >> +{ >> + struct richacl *acl = richacl_create(&inode->i_mode, dir); >> + int error; >> + >> + error = PTR_ERR(acl); >> + if (IS_ERR(acl)) >> + return error; > > if (IS_ERR(acl)) > return PTR_ERR(acl); > >> + if (acl) { >> + error = __ext4_set_richacl(handle, inode, acl); >> + richacl_put(acl); >> + } > > Shouldn't richacl_create return NULL if the ACL is equivalent to the > mode bits instead of letting every filesystem figure that out on it's > own? Hm, that's what it does? Thanks, Andreas -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Fri, Mar 11, 2016 at 3:27 PM, Christoph Hellwig <hch@infradead.org> wrote: >> +static inline int >> +ext4_acl_chmod(struct inode *inode, umode_t mode) >> +{ >> + if (IS_RICHACL(inode)) >> + return richacl_chmod(inode, inode->i_mode); >> + return posix_acl_chmod(inode, inode->i_mode); >> +} > > Thi isn't ext4-specific and potentially duplicated in every caller. > Please provide this as a common helper. This can go in neither fs.h nor posix_acl.h nor richacl.h unless we turn it into a macro, and I don't think we want to add a new header file for such extreme trivia. > Also while we're at it, the mode argument is ignore and the function > always uses inode->i_mode instead. Right, thanks. Andreas -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Mon, Mar 14, 2016 at 12:08:31AM +0100, Andreas Gruenbacher wrote: > The xattr representation is the same on disk and at the xattr syscall > layer, and so richacl_from_xattr is used for converting into the > in-memory representation in both cases. The error codes are not the > same when a user supplies an invalid value via setxattr or NFS and > when an invalid xattr is read from disk though. I'll add a parameter > to richacl_from_xattr to make this more explicit. Better add a wrapper instead of a parameter. > > >> +static int > >> +__ext4_set_richacl(handle_t *handle, struct inode *inode, struct richacl *acl) > >> +{ > >> + const int name_index = EXT4_XATTR_INDEX_RICHACL; > >> + umode_t mode = inode->i_mode; > >> + int retval, size; > >> + void *value; > >> + > >> + if (richacl_equiv_mode(acl, &mode) == 0) { > >> + inode->i_ctime = ext4_current_time(inode); > >> + inode->i_mode = mode; > >> + ext4_mark_inode_dirty(handle, inode); > >> + return __ext4_remove_richacl(handle, inode); > >> + } > > > > Should this check for a NULL acl instead of special casing that > > in ext4_set_richacl? > > I'm not sure I understand what you mean. When the ext4_set_richacl checks for a NULL acl pointer and then calls into __ext4_remove_richacl. I'd rather have that special casing in one place. -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Mon, Mar 14, 2016 at 02:02:33PM +0100, Andreas Gruenbacher wrote: > On Fri, Mar 11, 2016 at 3:27 PM, Christoph Hellwig <hch@infradead.org> wrote: > >> +static inline int > >> +ext4_acl_chmod(struct inode *inode, umode_t mode) > >> +{ > >> + if (IS_RICHACL(inode)) > >> + return richacl_chmod(inode, inode->i_mode); > >> + return posix_acl_chmod(inode, inode->i_mode); > >> +} > > > > Thi isn't ext4-specific and potentially duplicated in every caller. > > Please provide this as a common helper. > > This can go in neither fs.h nor posix_acl.h nor richacl.h unless we > turn it into a macro, and I don't think we want to add a new header > file for such extreme trivia. I'd expect us to grow a few more of thos helper if we get the sharing right (either a real common base object, or wrappers for anything dealing with the acl pointers in the inode), so a new linux/acl.h should be fine. -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Mar 15, 2016 at 8:17 AM, Christoph Hellwig <hch@infradead.org> wrote: > On Mon, Mar 14, 2016 at 12:08:31AM +0100, Andreas Gruenbacher wrote: >> The xattr representation is the same on disk and at the xattr syscall >> layer, and so richacl_from_xattr is used for converting into the >> in-memory representation in both cases. The error codes are not the >> same when a user supplies an invalid value via setxattr or NFS and >> when an invalid xattr is read from disk though. I'll add a parameter >> to richacl_from_xattr to make this more explicit. > > Better add a wrapper instead of a parameter. > >> >> >> +static int >> >> +__ext4_set_richacl(handle_t *handle, struct inode *inode, struct richacl *acl) >> >> +{ >> >> + const int name_index = EXT4_XATTR_INDEX_RICHACL; >> >> + umode_t mode = inode->i_mode; >> >> + int retval, size; >> >> + void *value; >> >> + >> >> + if (richacl_equiv_mode(acl, &mode) == 0) { >> >> + inode->i_ctime = ext4_current_time(inode); >> >> + inode->i_mode = mode; >> >> + ext4_mark_inode_dirty(handle, inode); >> >> + return __ext4_remove_richacl(handle, inode); >> >> + } >> > >> > Should this check for a NULL acl instead of special casing that >> > in ext4_set_richacl? >> >> I'm not sure I understand what you mean. When the > > ext4_set_richacl checks for a NULL acl pointer and then calls into > __ext4_remove_richacl. I'd rather have that special casing in one > place. Those are two different cases: the first is where ext4_set_richacl is called with a NULL acl to remove an existing ACL; the second is where ext4_set_richacl is called with a mode-equivalent ACL to set the mode and remove any existing ACL. The check for mode-equivalent ACLs is in __ext4_set_richacl and not in ext4_set_richacl because an inherited ACL (ext4_init_acl) can also be mode-equivalent. Andreas -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
diff --git a/fs/ext4/Kconfig b/fs/ext4/Kconfig index b46e9fc..4e21c18 100644 --- a/fs/ext4/Kconfig +++ b/fs/ext4/Kconfig @@ -22,6 +22,17 @@ config EXT3_FS_POSIX_ACL This config option is here only for backward compatibility. ext3 filesystem is now handled by the ext4 driver. +config EXT4_FS_RICHACL + bool "Ext4 Rich Access Control Lists" + depends on EXT4_FS + select FS_RICHACL + help + Richacls are an implementation of NFSv4 ACLs, extended by file masks + to cleanly integrate into the POSIX file permission model. To learn + more about them, see http://www.bestbits.at/richacl/. + + If you don't know what Richacls are, say N. + config EXT3_FS_SECURITY bool "Ext3 Security Labels" depends on EXT3_FS diff --git a/fs/ext4/Makefile b/fs/ext4/Makefile index f52cf54..1fb7f11 100644 --- a/fs/ext4/Makefile +++ b/fs/ext4/Makefile @@ -14,3 +14,4 @@ ext4-$(CONFIG_EXT4_FS_POSIX_ACL) += acl.o ext4-$(CONFIG_EXT4_FS_SECURITY) += xattr_security.o ext4-$(CONFIG_EXT4_FS_ENCRYPTION) += crypto_policy.o crypto.o \ crypto_key.o crypto_fname.o +ext4-$(CONFIG_EXT4_FS_RICHACL) += richacl.o diff --git a/fs/ext4/file.c b/fs/ext4/file.c index 474f1a4..30bfc50 100644 --- a/fs/ext4/file.c +++ b/fs/ext4/file.c @@ -30,6 +30,7 @@ #include "ext4_jbd2.h" #include "xattr.h" #include "acl.h" +#include "richacl.h" /* * Called when an inode is released. Note that this is different @@ -764,6 +765,8 @@ const struct inode_operations ext4_file_inode_operations = { .removexattr = generic_removexattr, .get_acl = ext4_get_acl, .set_acl = ext4_set_acl, + .get_richacl = ext4_get_richacl, + .set_richacl = ext4_set_richacl, .fiemap = ext4_fiemap, }; diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c index acc0ad5..f2d31c2 100644 --- a/fs/ext4/ialloc.c +++ b/fs/ext4/ialloc.c @@ -27,6 +27,7 @@ #include "ext4_jbd2.h" #include "xattr.h" #include "acl.h" +#include "richacl.h" #include <trace/events/ext4.h> @@ -729,6 +730,14 @@ out: return ret; } +static inline int +ext4_new_acl(handle_t *handle, struct inode *inode, struct inode *dir) +{ + if (IS_RICHACL(dir)) + return ext4_init_richacl(handle, inode, dir); + return ext4_init_acl(handle, inode, dir); +} + /* * There are two policies for allocating an inode. If the new inode is * a directory, then a forward search is made for a block group with both @@ -1093,7 +1102,7 @@ got: if (err) goto fail_drop; - err = ext4_init_acl(handle, inode, dir); + err = ext4_new_acl(handle, inode, dir); if (err) goto fail_free_drop; diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c index 9cc57c3..ef6fb86 100644 --- a/fs/ext4/inode.c +++ b/fs/ext4/inode.c @@ -42,6 +42,7 @@ #include "xattr.h" #include "acl.h" #include "truncate.h" +#include "richacl.h" #include <trace/events/ext4.h> @@ -4851,6 +4852,14 @@ static void ext4_wait_for_tail_page_commit(struct inode *inode) } } +static inline int +ext4_acl_chmod(struct inode *inode, umode_t mode) +{ + if (IS_RICHACL(inode)) + return richacl_chmod(inode, inode->i_mode); + return posix_acl_chmod(inode, inode->i_mode); +} + /* * ext4_setattr() * @@ -5021,8 +5030,7 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr) ext4_orphan_del(NULL, inode); if (!rc && (ia_valid & ATTR_MODE)) - rc = posix_acl_chmod(inode, inode->i_mode); - + rc = ext4_acl_chmod(inode, inode->i_mode); err_out: ext4_std_error(inode->i_sb, error); if (!error) diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c index 48e4b89..d86c5f2 100644 --- a/fs/ext4/namei.c +++ b/fs/ext4/namei.c @@ -38,6 +38,7 @@ #include "xattr.h" #include "acl.h" +#include "richacl.h" #include <trace/events/ext4.h> /* @@ -3888,6 +3889,8 @@ const struct inode_operations ext4_dir_inode_operations = { .removexattr = generic_removexattr, .get_acl = ext4_get_acl, .set_acl = ext4_set_acl, + .get_richacl = ext4_get_richacl, + .set_richacl = ext4_set_richacl, .fiemap = ext4_fiemap, }; @@ -3899,4 +3902,6 @@ const struct inode_operations ext4_special_inode_operations = { .removexattr = generic_removexattr, .get_acl = ext4_get_acl, .set_acl = ext4_set_acl, + .get_richacl = ext4_get_richacl, + .set_richacl = ext4_set_richacl, }; diff --git a/fs/ext4/richacl.c b/fs/ext4/richacl.c new file mode 100644 index 0000000..d581be4 --- /dev/null +++ b/fs/ext4/richacl.c @@ -0,0 +1,142 @@ +/* + * Copyright IBM Corporation, 2010 + * Copyright (C) 2015 Red Hat, Inc. + * Author: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>, + * Andreas Gruenbacher <agruenba@redhat.com> + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of version 2.1 of the GNU Lesser General Public License + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it would be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + */ + +#include <linux/kernel.h> +#include <linux/fs.h> +#include <linux/richacl_xattr.h> + +#include "ext4.h" +#include "ext4_jbd2.h" +#include "xattr.h" +#include "acl.h" +#include "richacl.h" + +struct richacl * +ext4_get_richacl(struct inode *inode) +{ + const int name_index = EXT4_XATTR_INDEX_RICHACL; + void *value = NULL; + struct richacl *acl = NULL; + int retval; + + retval = ext4_xattr_get(inode, name_index, "", NULL, 0); + if (retval > 0) { + value = kmalloc(retval, GFP_NOFS); + if (!value) + return ERR_PTR(-ENOMEM); + retval = ext4_xattr_get(inode, name_index, "", value, retval); + } + if (retval > 0) { + acl = richacl_from_xattr(&init_user_ns, value, retval); + if (acl == ERR_PTR(-EINVAL)) + acl = ERR_PTR(-EIO); + } else if (retval != -ENODATA && retval != -ENOSYS) { + acl = ERR_PTR(retval); + } + kfree(value); + + if (!IS_ERR(acl)) + set_cached_richacl(inode, acl); + + return acl; +} + +static int +__ext4_remove_richacl(handle_t *handle, struct inode *inode) +{ + const int name_index = EXT4_XATTR_INDEX_RICHACL; + int retval; + + retval = ext4_xattr_set_handle(handle, inode, name_index, "", + NULL, 0, 0); + if (!retval) + set_cached_richacl(inode, NULL); + return retval; +} + +static int +__ext4_set_richacl(handle_t *handle, struct inode *inode, struct richacl *acl) +{ + const int name_index = EXT4_XATTR_INDEX_RICHACL; + umode_t mode = inode->i_mode; + int retval, size; + void *value; + + if (richacl_equiv_mode(acl, &mode) == 0) { + inode->i_ctime = ext4_current_time(inode); + inode->i_mode = mode; + ext4_mark_inode_dirty(handle, inode); + return __ext4_remove_richacl(handle, inode); + } + + mode &= ~S_IRWXUGO; + mode |= richacl_masks_to_mode(acl); + + size = richacl_xattr_size(acl); + value = kmalloc(size, GFP_NOFS); + if (!value) + return -ENOMEM; + richacl_to_xattr(&init_user_ns, acl, value, size); + inode->i_mode = mode; + retval = ext4_xattr_set_handle(handle, inode, name_index, "", + value, size, 0); + kfree(value); + if (retval) + return retval; + + set_cached_richacl(inode, acl); + + return 0; +} + +int +ext4_set_richacl(struct inode *inode, struct richacl *acl) +{ + handle_t *handle; + int retval, retries = 0; + +retry: + handle = ext4_journal_start(inode, EXT4_HT_XATTR, + ext4_jbd2_credits_xattr(inode)); + if (IS_ERR(handle)) + return PTR_ERR(handle); + + if (acl) + retval = __ext4_set_richacl(handle, inode, acl); + else + retval = __ext4_remove_richacl(handle, inode); + + ext4_journal_stop(handle); + if (retval == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) + goto retry; + return retval; +} + +int +ext4_init_richacl(handle_t *handle, struct inode *inode, struct inode *dir) +{ + struct richacl *acl = richacl_create(&inode->i_mode, dir); + int error; + + error = PTR_ERR(acl); + if (IS_ERR(acl)) + return error; + if (acl) { + error = __ext4_set_richacl(handle, inode, acl); + richacl_put(acl); + } + return error; +} diff --git a/fs/ext4/richacl.h b/fs/ext4/richacl.h new file mode 100644 index 0000000..6fe9a92 --- /dev/null +++ b/fs/ext4/richacl.h @@ -0,0 +1,40 @@ +/* + * Copyright IBM Corporation, 2010 + * Copyright (C) 2015 Red Hat, Inc. + * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of version 2.1 of the GNU Lesser General Public License + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it would be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + */ + +#ifndef __FS_EXT4_RICHACL_H +#define __FS_EXT4_RICHACL_H + +#include <linux/richacl.h> + +#ifdef CONFIG_EXT4_FS_RICHACL + +extern struct richacl *ext4_get_richacl(struct inode *); +extern int ext4_set_richacl(struct inode *, struct richacl *); + +extern int ext4_init_richacl(handle_t *, struct inode *, struct inode *); + +#else /* CONFIG_EXT4_FS_RICHACL */ + +#define ext4_get_richacl NULL +#define ext4_set_richacl NULL + +static inline int +ext4_init_richacl(handle_t *handle, struct inode *inode, struct inode *dir) +{ + return 0; +} + +#endif /* CONFIG_EXT4_FS_RICHACL */ +#endif /* __FS_EXT4_RICHACL_H */ diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c index a95151e..ef76630 100644 --- a/fs/ext4/xattr.c +++ b/fs/ext4/xattr.c @@ -55,6 +55,7 @@ #include <linux/slab.h> #include <linux/mbcache.h> #include <linux/quotaops.h> +#include <linux/richacl_xattr.h> #include "ext4_jbd2.h" #include "ext4.h" #include "xattr.h" @@ -97,6 +98,9 @@ static const struct xattr_handler *ext4_xattr_handler_map[] = { #ifdef CONFIG_EXT4_FS_SECURITY [EXT4_XATTR_INDEX_SECURITY] = &ext4_xattr_security_handler, #endif +#ifdef CONFIG_EXT4_FS_RICHACL + [EXT4_XATTR_INDEX_RICHACL] = &richacl_xattr_handler, +#endif }; const struct xattr_handler *ext4_xattr_handlers[] = { @@ -109,6 +113,9 @@ const struct xattr_handler *ext4_xattr_handlers[] = { #ifdef CONFIG_EXT4_FS_SECURITY &ext4_xattr_security_handler, #endif +#ifdef CONFIG_EXT4_FS_RICHACL + &richacl_xattr_handler, +#endif NULL };