9p: implement get acl method

The current way of setting and getting posix acls through the generic
xattr interface is error prone and type unsafe. The vfs needs to
interpret and fixup posix acls before storing or reporting it to
userspace. Various hacks exist to make this work. The code is hard to
understand and difficult to maintain in it's current form. Instead of
making this work by hacking posix acls through xattr handlers we are
building a dedicated posix acl api around the get and set inode
operations. This removes a lot of hackiness and makes the codepaths
easier to maintain. A lot of background can be found in [1].

In order to build a type safe posix api around get and set acl we need
all filesystem to implement get and set acl.

So far 9p implemented a ->get_inode_acl() operation that didn't require
access to the dentry in order to allow (limited) permission checking via
posix acls in the vfs. Now that we have get and set acl inode operations
that take a dentry argument we can give 9p get and set acl inode
operations.

This is mostly a refactoring of the codepaths currently used in 9p posix
acl xattr handler. After we have fully implemented the posix acl api and
switched the vfs over to it, the 9p specific posix acl xattr handler and
associated code will be removed.

Note, until the vfs has been switched to the new posix acl api this
patch is a non-functional change.

Link: https://lore.kernel.org/all/20220801145520.1532837-1-brauner@kernel.org
Signed-off-by: Christian Brauner (Microsoft) <brauner@kernel.org>

diff --git a/fs/9p/acl.c b/fs/9p/acl.c
index 4dac4a0dc5f4111b7141b031670b1096102d72dd..67f8b57c67e067af273c5c7cc3c15ec429cda58e 100644 (file)
--- a/fs/9p/acl.c
+++ b/fs/9p/acl.c
@@ -17,34 +17,64 @@
 #include "v9fs_vfs.h"
 #include "fid.h"
 
-static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, char *name)
+static struct posix_acl *v9fs_fid_get_acl(struct p9_fid *fid, const char *name)
 {
        ssize_t size;
        void *value = NULL;
        struct posix_acl *acl = NULL;
 
        size = v9fs_fid_xattr_get(fid, name, NULL, 0);
-       if (size > 0) {
-               value = kzalloc(size, GFP_NOFS);
-               if (!value)
-                       return ERR_PTR(-ENOMEM);
-               size = v9fs_fid_xattr_get(fid, name, value, size);
-               if (size > 0) {
-                       acl = posix_acl_from_xattr(&init_user_ns, value, size);
-                       if (IS_ERR(acl))
-                               goto err_out;
-               }
-       } else if (size == -ENODATA || size == 0 ||
-                  size == -ENOSYS || size == -EOPNOTSUPP) {
-               acl = NULL;
-       } else
-               acl = ERR_PTR(-EIO);
-
-err_out:
+       if (size < 0)
+               return ERR_PTR(size);
+       if (size == 0)
+               return ERR_PTR(-ENODATA);
+
+       value = kzalloc(size, GFP_NOFS);
+       if (!value)
+               return ERR_PTR(-ENOMEM);
+
+       size = v9fs_fid_xattr_get(fid, name, value, size);
+       if (size < 0)
+               acl = ERR_PTR(size);
+       else if (size == 0)
+               acl = ERR_PTR(-ENODATA);
+       else
+               acl = posix_acl_from_xattr(&init_user_ns, value, size);
        kfree(value);
        return acl;
 }
 
+static struct posix_acl *v9fs_acl_get(struct dentry *dentry, const char *name)
+{
+       struct p9_fid *fid;
+       struct posix_acl *acl = NULL;
+
+       fid = v9fs_fid_lookup(dentry);
+       if (IS_ERR(fid))
+               return ERR_CAST(fid);
+
+       acl = v9fs_fid_get_acl(fid, name);
+       p9_fid_put(fid);
+       return acl;
+}
+
+static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, const char *name)
+{
+       int retval;
+       struct posix_acl *acl = NULL;
+
+       acl = v9fs_fid_get_acl(fid, name);
+       if (!IS_ERR(acl))
+               return acl;
+
+       retval = PTR_ERR(acl);
+       if (retval == -ENODATA || retval == -ENOSYS || retval == -EOPNOTSUPP)
+               return NULL;
+
+       /* map everything else to -EIO */
+       return ERR_PTR(-EIO);
+}
+
 int v9fs_get_acl(struct inode *inode, struct p9_fid *fid)
 {
        int retval = 0;
@@ -89,7 +119,7 @@ static struct posix_acl *v9fs_get_cached_acl(struct inode *inode, int type)
        return acl;
 }
 
-struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type, bool rcu)
+struct posix_acl *v9fs_iop_get_inode_acl(struct inode *inode, int type, bool rcu)
 {
        struct v9fs_session_info *v9ses;
 
@@ -109,6 +139,18 @@ struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type, bool rcu)
 
 }
 
+struct posix_acl *v9fs_iop_get_acl(struct user_namespace *mnt_userns,
+                                  struct dentry *dentry, int type)
+{
+       struct v9fs_session_info *v9ses;
+
+       v9ses = v9fs_dentry2v9ses(dentry);
+       /* We allow set/get/list of acl when access=client is not specified. */
+       if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT)
+               return v9fs_acl_get(dentry, posix_acl_xattr_name(type));
+       return v9fs_get_cached_acl(d_inode(dentry), type);
+}
+
 static int v9fs_set_acl(struct p9_fid *fid, int type, struct posix_acl *acl)
 {
        int retval;

diff --git a/fs/9p/acl.h b/fs/9p/acl.h
index ce5175d463dddfaa684e1dd50286ca319111db78..359dab4da9006551a884a6a9a77e3e15db61843d 100644 (file)
--- a/fs/9p/acl.h
+++ b/fs/9p/acl.h
@@ -8,8 +8,10 @@
 
 #ifdef CONFIG_9P_FS_POSIX_ACL
 int v9fs_get_acl(struct inode *inode, struct p9_fid *fid);
-struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type,
+struct posix_acl *v9fs_iop_get_inode_acl(struct inode *inode, int type,
                                   bool rcu);
+struct posix_acl *v9fs_iop_get_acl(struct user_namespace *mnt_userns,
+                                         struct dentry *dentry, int type);
 int v9fs_acl_chmod(struct inode *inode, struct p9_fid *fid);
 int v9fs_set_create_acl(struct inode *inode, struct p9_fid *fid,
                        struct posix_acl *dacl, struct posix_acl *acl);
@@ -17,6 +19,7 @@ int v9fs_acl_mode(struct inode *dir, umode_t *modep,
                  struct posix_acl **dpacl, struct posix_acl **pacl);
 void v9fs_put_acl(struct posix_acl *dacl, struct posix_acl *acl);
 #else
+#define v9fs_iop_get_inode_acl NULL
 #define v9fs_iop_get_acl NULL
 static inline int v9fs_get_acl(struct inode *inode, struct p9_fid *fid)
 {

diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
index 0d1a7f2c579d33f80a293e0a98ff9139ebf4965c..a4211fcb91682ad4c555bac8e2e041bb2a291dbf 100644 (file)
--- a/fs/9p/vfs_inode_dotl.c
+++ b/fs/9p/vfs_inode_dotl.c
@@ -983,14 +983,16 @@ const struct inode_operations v9fs_dir_inode_operations_dotl = {
        .getattr = v9fs_vfs_getattr_dotl,
        .setattr = v9fs_vfs_setattr_dotl,
        .listxattr = v9fs_listxattr,
-       .get_inode_acl = v9fs_iop_get_acl,
+       .get_inode_acl = v9fs_iop_get_inode_acl,
+       .get_acl = v9fs_iop_get_acl,
 };
 
 const struct inode_operations v9fs_file_inode_operations_dotl = {
        .getattr = v9fs_vfs_getattr_dotl,
        .setattr = v9fs_vfs_setattr_dotl,
        .listxattr = v9fs_listxattr,
-       .get_inode_acl = v9fs_iop_get_acl,
+       .get_inode_acl = v9fs_iop_get_inode_acl,
+       .get_acl = v9fs_iop_get_acl,
 };
 
 const struct inode_operations v9fs_symlink_inode_operations_dotl = {

diff --git a/include/linux/posix_acl_xattr.h b/include/linux/posix_acl_xattr.h
index 8163dd48c430189eb6b512aa3db6df07eb0016d5..ebfa11ac7046a0cf9238b8f43f882203ff98029a 100644 (file)
--- a/include/linux/posix_acl_xattr.h
+++ b/include/linux/posix_acl_xattr.h
@@ -60,6 +60,17 @@ int posix_acl_to_xattr(struct user_namespace *user_ns,
 struct posix_acl *vfs_set_acl_prepare(struct user_namespace *mnt_userns,
                                      struct user_namespace *fs_userns,
                                      const void *value, size_t size);
+static inline const char *posix_acl_xattr_name(int type)
+{
+       switch (type) {
+       case ACL_TYPE_ACCESS:
+               return XATTR_NAME_POSIX_ACL_ACCESS;
+       case ACL_TYPE_DEFAULT:
+               return XATTR_NAME_POSIX_ACL_DEFAULT;
+       }
+
+       return "";
+}
 
 extern const struct xattr_handler posix_acl_access_xattr_handler;
 extern const struct xattr_handler posix_acl_default_xattr_handler;