Dave Chinner | 0b61f8a | 2018-06-05 19:42:14 -0700 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (C) 2008 Christoph Hellwig. |
| 4 | * Portions Copyright (C) 2000-2008 Silicon Graphics, Inc. |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 5 | */ |
| 6 | |
| 7 | #include "xfs.h" |
Darrick J. Wong | 5467b34 | 2019-06-28 19:25:35 -0700 | [diff] [blame] | 8 | #include "xfs_shared.h" |
Dave Chinner | a4fbe6a | 2013-10-23 10:51:50 +1100 | [diff] [blame] | 9 | #include "xfs_format.h" |
Dave Chinner | 6943283 | 2013-08-12 20:49:23 +1000 | [diff] [blame] | 10 | #include "xfs_log_format.h" |
Dave Chinner | 5706278 | 2013-10-15 09:17:51 +1100 | [diff] [blame] | 11 | #include "xfs_da_format.h" |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 12 | #include "xfs_inode.h" |
| 13 | #include "xfs_attr.h" |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 14 | |
| 15 | #include <linux/posix_acl_xattr.h> |
| 16 | #include <linux/xattr.h> |
| 17 | |
| 18 | |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 19 | static int |
Al Viro | b296821 | 2016-04-10 20:48:24 -0400 | [diff] [blame] | 20 | xfs_xattr_get(const struct xattr_handler *handler, struct dentry *unused, |
| 21 | struct inode *inode, const char *name, void *value, size_t size) |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 22 | { |
Andreas Gruenbacher | d9a82a0 | 2015-10-04 19:18:51 +0200 | [diff] [blame] | 23 | int xflags = handler->flags; |
Al Viro | b296821 | 2016-04-10 20:48:24 -0400 | [diff] [blame] | 24 | struct xfs_inode *ip = XFS_I(inode); |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 25 | int error, asize = size; |
| 26 | |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 27 | /* Convert Linux syscall to XFS internal ATTR flags */ |
| 28 | if (!size) { |
| 29 | xflags |= ATTR_KERNOVAL; |
| 30 | value = NULL; |
| 31 | } |
| 32 | |
Dave Chinner | ddbca70 | 2019-08-29 09:04:10 -0700 | [diff] [blame] | 33 | error = xfs_attr_get(ip, name, (unsigned char **)&value, &asize, xflags); |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 34 | if (error) |
| 35 | return error; |
| 36 | return asize; |
| 37 | } |
| 38 | |
Andreas Gruenbacher | 47e1bf6 | 2015-11-03 12:56:17 +1100 | [diff] [blame] | 39 | void |
| 40 | xfs_forget_acl( |
| 41 | struct inode *inode, |
| 42 | const char *name, |
| 43 | int xflags) |
| 44 | { |
| 45 | /* |
| 46 | * Invalidate any cached ACLs if the user has bypassed the ACL |
| 47 | * interface. We don't validate the content whatsoever so it is caller |
| 48 | * responsibility to provide data in valid format and ensure i_mode is |
| 49 | * consistent. |
| 50 | */ |
| 51 | if (xflags & ATTR_ROOT) { |
| 52 | #ifdef CONFIG_XFS_POSIX_ACL |
| 53 | if (!strcmp(name, SGI_ACL_FILE)) |
| 54 | forget_cached_acl(inode, ACL_TYPE_ACCESS); |
| 55 | else if (!strcmp(name, SGI_ACL_DEFAULT)) |
| 56 | forget_cached_acl(inode, ACL_TYPE_DEFAULT); |
| 57 | #endif |
| 58 | } |
| 59 | } |
| 60 | |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 61 | static int |
Al Viro | 5930122 | 2016-05-27 10:19:30 -0400 | [diff] [blame] | 62 | xfs_xattr_set(const struct xattr_handler *handler, struct dentry *unused, |
| 63 | struct inode *inode, const char *name, const void *value, |
| 64 | size_t size, int flags) |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 65 | { |
Linus Torvalds | 5d2eb54 | 2015-11-13 18:02:30 -0800 | [diff] [blame] | 66 | int xflags = handler->flags; |
Al Viro | 5930122 | 2016-05-27 10:19:30 -0400 | [diff] [blame] | 67 | struct xfs_inode *ip = XFS_I(inode); |
Brian Foster | 67d8e04 | 2015-11-03 12:40:59 +1100 | [diff] [blame] | 68 | int error; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 69 | |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 70 | /* Convert Linux syscall to XFS internal ATTR flags */ |
| 71 | if (flags & XATTR_CREATE) |
| 72 | xflags |= ATTR_CREATE; |
| 73 | if (flags & XATTR_REPLACE) |
| 74 | xflags |= ATTR_REPLACE; |
| 75 | |
| 76 | if (!value) |
Dave Chinner | 2451337 | 2014-06-25 14:58:08 +1000 | [diff] [blame] | 77 | return xfs_attr_remove(ip, (unsigned char *)name, xflags); |
Brian Foster | 67d8e04 | 2015-11-03 12:40:59 +1100 | [diff] [blame] | 78 | error = xfs_attr_set(ip, (unsigned char *)name, |
Dave Chinner | a9273ca | 2010-01-20 10:47:48 +1100 | [diff] [blame] | 79 | (void *)value, size, xflags); |
Andreas Gruenbacher | 47e1bf6 | 2015-11-03 12:56:17 +1100 | [diff] [blame] | 80 | if (!error) |
Al Viro | 5930122 | 2016-05-27 10:19:30 -0400 | [diff] [blame] | 81 | xfs_forget_acl(inode, name, xflags); |
Brian Foster | 67d8e04 | 2015-11-03 12:40:59 +1100 | [diff] [blame] | 82 | |
| 83 | return error; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 84 | } |
| 85 | |
Stephen Hemminger | 46e5876 | 2010-05-13 17:53:20 -0700 | [diff] [blame] | 86 | static const struct xattr_handler xfs_xattr_user_handler = { |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 87 | .prefix = XATTR_USER_PREFIX, |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 88 | .flags = 0, /* no flags implies user namespace */ |
| 89 | .get = xfs_xattr_get, |
| 90 | .set = xfs_xattr_set, |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 91 | }; |
| 92 | |
Stephen Hemminger | 46e5876 | 2010-05-13 17:53:20 -0700 | [diff] [blame] | 93 | static const struct xattr_handler xfs_xattr_trusted_handler = { |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 94 | .prefix = XATTR_TRUSTED_PREFIX, |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 95 | .flags = ATTR_ROOT, |
| 96 | .get = xfs_xattr_get, |
| 97 | .set = xfs_xattr_set, |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 98 | }; |
| 99 | |
Stephen Hemminger | 46e5876 | 2010-05-13 17:53:20 -0700 | [diff] [blame] | 100 | static const struct xattr_handler xfs_xattr_security_handler = { |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 101 | .prefix = XATTR_SECURITY_PREFIX, |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 102 | .flags = ATTR_SECURE, |
| 103 | .get = xfs_xattr_get, |
| 104 | .set = xfs_xattr_set, |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 105 | }; |
| 106 | |
Stephen Hemminger | 46e5876 | 2010-05-13 17:53:20 -0700 | [diff] [blame] | 107 | const struct xattr_handler *xfs_xattr_handlers[] = { |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 108 | &xfs_xattr_user_handler, |
| 109 | &xfs_xattr_trusted_handler, |
| 110 | &xfs_xattr_security_handler, |
Christoph Hellwig | ef14f0c | 2009-06-10 17:07:47 +0200 | [diff] [blame] | 111 | #ifdef CONFIG_XFS_POSIX_ACL |
Christoph Hellwig | 2401dc2 | 2013-12-20 05:16:50 -0800 | [diff] [blame] | 112 | &posix_acl_access_xattr_handler, |
| 113 | &posix_acl_default_xattr_handler, |
Christoph Hellwig | ef14f0c | 2009-06-10 17:07:47 +0200 | [diff] [blame] | 114 | #endif |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 115 | NULL |
| 116 | }; |
| 117 | |
Eric Sandeen | f7a136a | 2016-12-05 12:32:14 +1100 | [diff] [blame] | 118 | static void |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 119 | __xfs_xattr_put_listent( |
| 120 | struct xfs_attr_list_context *context, |
| 121 | char *prefix, |
| 122 | int prefix_len, |
| 123 | unsigned char *name, |
| 124 | int namelen) |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 125 | { |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 126 | char *offset; |
| 127 | int arraytop; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 128 | |
Darrick J. Wong | 3b50086 | 2019-02-13 11:15:17 -0800 | [diff] [blame] | 129 | if (context->count < 0 || context->seen_enough) |
| 130 | return; |
| 131 | |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 132 | if (!context->alist) |
| 133 | goto compute_size; |
| 134 | |
| 135 | arraytop = context->count + prefix_len + namelen + 1; |
| 136 | if (arraytop > context->firstu) { |
| 137 | context->count = -1; /* insufficient space */ |
Artem Savkov | 791cc43 | 2016-09-14 07:40:35 +1000 | [diff] [blame] | 138 | context->seen_enough = 1; |
Eric Sandeen | f7a136a | 2016-12-05 12:32:14 +1100 | [diff] [blame] | 139 | return; |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 140 | } |
| 141 | offset = (char *)context->alist + context->count; |
| 142 | strncpy(offset, prefix, prefix_len); |
| 143 | offset += prefix_len; |
| 144 | strncpy(offset, (char *)name, namelen); /* real name */ |
| 145 | offset += namelen; |
| 146 | *offset = '\0'; |
| 147 | |
| 148 | compute_size: |
| 149 | context->count += prefix_len + namelen + 1; |
Eric Sandeen | f7a136a | 2016-12-05 12:32:14 +1100 | [diff] [blame] | 150 | return; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 151 | } |
| 152 | |
Eric Sandeen | f7a136a | 2016-12-05 12:32:14 +1100 | [diff] [blame] | 153 | static void |
Dave Chinner | a9273ca | 2010-01-20 10:47:48 +1100 | [diff] [blame] | 154 | xfs_xattr_put_listent( |
| 155 | struct xfs_attr_list_context *context, |
| 156 | int flags, |
| 157 | unsigned char *name, |
| 158 | int namelen, |
Eric Sandeen | e5bd12b | 2016-04-06 07:57:32 +1000 | [diff] [blame] | 159 | int valuelen) |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 160 | { |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 161 | char *prefix; |
| 162 | int prefix_len; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 163 | |
| 164 | ASSERT(context->count >= 0); |
| 165 | |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 166 | if (flags & XFS_ATTR_ROOT) { |
| 167 | #ifdef CONFIG_XFS_POSIX_ACL |
| 168 | if (namelen == SGI_ACL_FILE_SIZE && |
| 169 | strncmp(name, SGI_ACL_FILE, |
| 170 | SGI_ACL_FILE_SIZE) == 0) { |
Eric Sandeen | f7a136a | 2016-12-05 12:32:14 +1100 | [diff] [blame] | 171 | __xfs_xattr_put_listent( |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 172 | context, XATTR_SYSTEM_PREFIX, |
| 173 | XATTR_SYSTEM_PREFIX_LEN, |
| 174 | XATTR_POSIX_ACL_ACCESS, |
| 175 | strlen(XATTR_POSIX_ACL_ACCESS)); |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 176 | } else if (namelen == SGI_ACL_DEFAULT_SIZE && |
| 177 | strncmp(name, SGI_ACL_DEFAULT, |
| 178 | SGI_ACL_DEFAULT_SIZE) == 0) { |
Eric Sandeen | f7a136a | 2016-12-05 12:32:14 +1100 | [diff] [blame] | 179 | __xfs_xattr_put_listent( |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 180 | context, XATTR_SYSTEM_PREFIX, |
| 181 | XATTR_SYSTEM_PREFIX_LEN, |
| 182 | XATTR_POSIX_ACL_DEFAULT, |
| 183 | strlen(XATTR_POSIX_ACL_DEFAULT)); |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 184 | } |
| 185 | #endif |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 186 | |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 187 | /* |
| 188 | * Only show root namespace entries if we are actually allowed to |
| 189 | * see them. |
| 190 | */ |
| 191 | if (!capable(CAP_SYS_ADMIN)) |
Eric Sandeen | f7a136a | 2016-12-05 12:32:14 +1100 | [diff] [blame] | 192 | return; |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 193 | |
| 194 | prefix = XATTR_TRUSTED_PREFIX; |
| 195 | prefix_len = XATTR_TRUSTED_PREFIX_LEN; |
| 196 | } else if (flags & XFS_ATTR_SECURE) { |
| 197 | prefix = XATTR_SECURITY_PREFIX; |
| 198 | prefix_len = XATTR_SECURITY_PREFIX_LEN; |
| 199 | } else { |
| 200 | prefix = XATTR_USER_PREFIX; |
| 201 | prefix_len = XATTR_USER_PREFIX_LEN; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 202 | } |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 203 | |
Eric Sandeen | f7a136a | 2016-12-05 12:32:14 +1100 | [diff] [blame] | 204 | __xfs_xattr_put_listent(context, prefix, prefix_len, name, |
| 205 | namelen); |
| 206 | return; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 207 | } |
| 208 | |
| 209 | ssize_t |
Eric Sandeen | 2a6fba6 | 2016-04-06 07:57:18 +1000 | [diff] [blame] | 210 | xfs_vn_listxattr( |
| 211 | struct dentry *dentry, |
| 212 | char *data, |
| 213 | size_t size) |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 214 | { |
| 215 | struct xfs_attr_list_context context; |
| 216 | struct attrlist_cursor_kern cursor = { 0 }; |
Eric Sandeen | 2a6fba6 | 2016-04-06 07:57:18 +1000 | [diff] [blame] | 217 | struct inode *inode = d_inode(dentry); |
| 218 | int error; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 219 | |
| 220 | /* |
| 221 | * First read the regular on-disk attributes. |
| 222 | */ |
| 223 | memset(&context, 0, sizeof(context)); |
| 224 | context.dp = XFS_I(inode); |
| 225 | context.cursor = &cursor; |
| 226 | context.resynch = 1; |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 227 | context.alist = size ? data : NULL; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 228 | context.bufsize = size; |
| 229 | context.firstu = context.bufsize; |
Andreas Gruenbacher | 5d92b75 | 2015-12-02 14:44:40 +0100 | [diff] [blame] | 230 | context.put_listent = xfs_xattr_put_listent; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 231 | |
Eric Sandeen | 2a6fba6 | 2016-04-06 07:57:18 +1000 | [diff] [blame] | 232 | error = xfs_attr_list_int(&context); |
| 233 | if (error) |
| 234 | return error; |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 235 | if (context.count < 0) |
| 236 | return -ERANGE; |
| 237 | |
Lachlan McIlroy | f9e09f0 | 2008-06-23 13:34:09 +1000 | [diff] [blame] | 238 | return context.count; |
| 239 | } |