From patchwork Thu Sep 22 15:17:04 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Christian Brauner X-Patchwork-Id: 12985403 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D52B8C6FA82 for ; Thu, 22 Sep 2022 15:19:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232048AbiIVPTE (ORCPT ); Thu, 22 Sep 2022 11:19:04 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:41180 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231455AbiIVPS2 (ORCPT ); Thu, 22 Sep 2022 11:18:28 -0400 Received: from ams.source.kernel.org (ams.source.kernel.org [IPv6:2604:1380:4601:e00::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 28D14EFF63 for ; Thu, 22 Sep 2022 08:18:05 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 5E462B8383A for ; Thu, 22 Sep 2022 15:18:03 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id EF882C433D6; Thu, 22 Sep 2022 15:17:59 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1663859882; bh=DBFXKEGvpKcV+yq63MQJfjJYsa2v1TlZC4IZsUNCpVo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=dKQttyeH9XbKSS3Q7+9XV+CMxnXeK2W/sVNdazG4K5b7z7lIRw7dXrnEXXxRDg8pC /sCZoBK8fhnJpM5VmkT0CFN6gF8w+I1Q/7o2K9PnP3+evpFTY8MyA6EZuibcjmvl6f tqRRwkYujAY7/i0Tx1ht0LrrPBEb0N8CDq9S+GGMM1X9lxtvIm+c8Ch9T+hVPi/In9 WaWP/DtmSSoh0NziITC5WviQqY+7dgPXA0WZRNYDppZCxXYUeehV2yFbj5VIYtjMWs N3wX6/n2oUVhUcD/yc88rdOOdh4x6+Uf62aU85ko+Iyvht/d0sBKTNjVvtiLdf58za eLVJOP1gT0qZA== From: Christian Brauner To: linux-fsdevel@vger.kernel.org Cc: Christian Brauner , Seth Forshee , Christoph Hellwig , Al Viro , Eric Van Hensbergen , Latchesar Ionkov , Dominique Martinet , Christian Schoenebeck , v9fs-developer@lists.sourceforge.net Subject: [PATCH 06/29] 9p: implement get acl method Date: Thu, 22 Sep 2022 17:17:04 +0200 Message-Id: <20220922151728.1557914-7-brauner@kernel.org> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20220922151728.1557914-1-brauner@kernel.org> References: <20220922151728.1557914-1-brauner@kernel.org> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=8114; i=brauner@kernel.org; h=from:subject; bh=DBFXKEGvpKcV+yq63MQJfjJYsa2v1TlZC4IZsUNCpVo=; b=owGbwMvMwCU28Zj0gdSKO4sYT6slMSTr1FSs0aoWrWP43V7/d/qk0g1THh4/5bVzo+tCN3X+24za r0J4OkpZGMS4GGTFFFkc2k3C5ZbzVGw2ytSAmcPKBDKEgYtTACZysZ2RYSrHnMf5FTK9qot0Sm9dDJ 2jabNL2rtuy0/uKTOvJP6fJ87wT73szK2lkVfuCPy9xiN2p57/hfPPD/PeWgvK7pkmrWX8gQMA X-Developer-Key: i=brauner@kernel.org; a=openpgp; fpr=4880B8C9BD0E5106FC070F4F7B3C391EFEA93624 Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org 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 light 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 [1] Signed-off-by: Christian Brauner (Microsoft) --- fs/9p/acl.c | 97 +++++++++++++++++++++++++++------ fs/9p/acl.h | 11 +++- fs/9p/vfs_inode_dotl.c | 6 +- include/linux/posix_acl_xattr.h | 11 ++++ 4 files changed, 104 insertions(+), 21 deletions(-) diff --git a/fs/9p/acl.c b/fs/9p/acl.c index 4dac4a0dc5f4..0ef3386cf61a 100644 --- a/fs/9p/acl.c +++ b/fs/9p/acl.c @@ -17,34 +17,77 @@ #include "v9fs_vfs.h" #include "fid.h" -static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, char *name) +static int v9fs_fid_get_acl(struct p9_fid *fid, const char *name, + struct posix_acl **kacl) { 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); + if (size <= 0) + goto out; -err_out: + /* just return the size */ + if (!kacl) + goto out; + + value = kzalloc(size, GFP_NOFS); + if (!value) { + size = -ENOMEM; + goto out; + } + + size = v9fs_fid_xattr_get(fid, name, value, size); + if (size <= 0) + goto out; + + acl = posix_acl_from_xattr(&init_user_ns, value, size); + if (IS_ERR(acl)) { + size = PTR_ERR(acl); + goto out; + } + *kacl = acl; + +out: kfree(value); + return size; +} + +static struct posix_acl *v9fs_acl_get(struct dentry *dentry, const char *name) +{ + ssize_t size; + struct p9_fid *fid; + struct posix_acl *acl = NULL; + + fid = v9fs_fid_lookup(dentry); + if (IS_ERR(fid)) + return ERR_CAST(fid); + + size = v9fs_fid_get_acl(fid, name, &acl); + p9_fid_put(fid); + + if (size < 0) + return ERR_PTR(size); + return acl; } +static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, const char *name) +{ + ssize_t size; + struct posix_acl *acl = NULL; + + size = v9fs_fid_get_acl(fid, name, &acl); + if (size > 0) + return acl; + else if (size == -ENODATA || size == 0 || size == -ENOSYS || + size == -EOPNOTSUPP) + return NULL; + + return ERR_PTR(-EIO); +} + int v9fs_get_acl(struct inode *inode, struct p9_fid *fid) { int retval = 0; @@ -89,7 +132,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 +152,24 @@ 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; + struct posix_acl *acl = NULL; + + 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) + acl = v9fs_acl_get(dentry, posix_acl_xattr_name(type)); + else + acl = v9fs_get_cached_acl(d_inode(dentry), type); + if (IS_ERR(acl)) + return acl; + + return acl; +} + 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 ce5175d463dd..11d3f8ea4ce4 100644 --- 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,11 +19,18 @@ 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) { return 0; } +static inline struct posix_acl * +v9fs_iop_get_acl(struct user_namespace *mnt_userns, + struct dentry *dentry, int type) +{ + return NULL; +} static inline int v9fs_acl_chmod(struct inode *inode, struct p9_fid *fid) { return 0; diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c index 0d1a7f2c579d..a4211fcb9168 100644 --- 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 8163dd48c430..ebfa11ac7046 100644 --- 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;