Commit | Line | Data |
---|---|---|
0b61f8a4 | 1 | // SPDX-License-Identifier: GPL-2.0 |
f9e09f09 LM |
2 | /* |
3 | * Copyright (C) 2008 Christoph Hellwig. | |
4 | * Portions Copyright (C) 2000-2008 Silicon Graphics, Inc. | |
f9e09f09 LM |
5 | */ |
6 | ||
7 | #include "xfs.h" | |
a4fbe6ab | 8 | #include "xfs_format.h" |
69432832 | 9 | #include "xfs_log_format.h" |
239880ef | 10 | #include "xfs_trans_resv.h" |
57062787 DC |
11 | #include "xfs_mount.h" |
12 | #include "xfs_da_format.h" | |
f9e09f09 LM |
13 | #include "xfs_inode.h" |
14 | #include "xfs_attr.h" | |
15 | #include "xfs_attr_leaf.h" | |
16 | #include "xfs_acl.h" | |
f9e09f09 LM |
17 | |
18 | #include <linux/posix_acl_xattr.h> | |
19 | #include <linux/xattr.h> | |
20 | ||
21 | ||
f9e09f09 | 22 | static int |
b296821a AV |
23 | xfs_xattr_get(const struct xattr_handler *handler, struct dentry *unused, |
24 | struct inode *inode, const char *name, void *value, size_t size) | |
f9e09f09 | 25 | { |
d9a82a04 | 26 | int xflags = handler->flags; |
b296821a | 27 | struct xfs_inode *ip = XFS_I(inode); |
f9e09f09 LM |
28 | int error, asize = size; |
29 | ||
f9e09f09 LM |
30 | /* Convert Linux syscall to XFS internal ATTR flags */ |
31 | if (!size) { | |
32 | xflags |= ATTR_KERNOVAL; | |
33 | value = NULL; | |
34 | } | |
35 | ||
2451337d | 36 | error = xfs_attr_get(ip, (unsigned char *)name, value, &asize, xflags); |
f9e09f09 LM |
37 | if (error) |
38 | return error; | |
39 | return asize; | |
40 | } | |
41 | ||
47e1bf64 AG |
42 | void |
43 | xfs_forget_acl( | |
44 | struct inode *inode, | |
45 | const char *name, | |
46 | int xflags) | |
47 | { | |
48 | /* | |
49 | * Invalidate any cached ACLs if the user has bypassed the ACL | |
50 | * interface. We don't validate the content whatsoever so it is caller | |
51 | * responsibility to provide data in valid format and ensure i_mode is | |
52 | * consistent. | |
53 | */ | |
54 | if (xflags & ATTR_ROOT) { | |
55 | #ifdef CONFIG_XFS_POSIX_ACL | |
56 | if (!strcmp(name, SGI_ACL_FILE)) | |
57 | forget_cached_acl(inode, ACL_TYPE_ACCESS); | |
58 | else if (!strcmp(name, SGI_ACL_DEFAULT)) | |
59 | forget_cached_acl(inode, ACL_TYPE_DEFAULT); | |
60 | #endif | |
61 | } | |
62 | } | |
63 | ||
f9e09f09 | 64 | static int |
59301226 AV |
65 | xfs_xattr_set(const struct xattr_handler *handler, struct dentry *unused, |
66 | struct inode *inode, const char *name, const void *value, | |
67 | size_t size, int flags) | |
f9e09f09 | 68 | { |
5d2eb548 | 69 | int xflags = handler->flags; |
59301226 | 70 | struct xfs_inode *ip = XFS_I(inode); |
67d8e04e | 71 | int error; |
f9e09f09 | 72 | |
f9e09f09 LM |
73 | /* Convert Linux syscall to XFS internal ATTR flags */ |
74 | if (flags & XATTR_CREATE) | |
75 | xflags |= ATTR_CREATE; | |
76 | if (flags & XATTR_REPLACE) | |
77 | xflags |= ATTR_REPLACE; | |
78 | ||
79 | if (!value) | |
2451337d | 80 | return xfs_attr_remove(ip, (unsigned char *)name, xflags); |
67d8e04e | 81 | error = xfs_attr_set(ip, (unsigned char *)name, |
a9273ca5 | 82 | (void *)value, size, xflags); |
47e1bf64 | 83 | if (!error) |
59301226 | 84 | xfs_forget_acl(inode, name, xflags); |
67d8e04e BF |
85 | |
86 | return error; | |
f9e09f09 LM |
87 | } |
88 | ||
46e58764 | 89 | static const struct xattr_handler xfs_xattr_user_handler = { |
f9e09f09 | 90 | .prefix = XATTR_USER_PREFIX, |
431547b3 CH |
91 | .flags = 0, /* no flags implies user namespace */ |
92 | .get = xfs_xattr_get, | |
93 | .set = xfs_xattr_set, | |
f9e09f09 LM |
94 | }; |
95 | ||
46e58764 | 96 | static const struct xattr_handler xfs_xattr_trusted_handler = { |
f9e09f09 | 97 | .prefix = XATTR_TRUSTED_PREFIX, |
431547b3 CH |
98 | .flags = ATTR_ROOT, |
99 | .get = xfs_xattr_get, | |
100 | .set = xfs_xattr_set, | |
f9e09f09 LM |
101 | }; |
102 | ||
46e58764 | 103 | static const struct xattr_handler xfs_xattr_security_handler = { |
f9e09f09 | 104 | .prefix = XATTR_SECURITY_PREFIX, |
431547b3 CH |
105 | .flags = ATTR_SECURE, |
106 | .get = xfs_xattr_get, | |
107 | .set = xfs_xattr_set, | |
f9e09f09 LM |
108 | }; |
109 | ||
46e58764 | 110 | const struct xattr_handler *xfs_xattr_handlers[] = { |
f9e09f09 LM |
111 | &xfs_xattr_user_handler, |
112 | &xfs_xattr_trusted_handler, | |
113 | &xfs_xattr_security_handler, | |
ef14f0c1 | 114 | #ifdef CONFIG_XFS_POSIX_ACL |
2401dc29 CH |
115 | &posix_acl_access_xattr_handler, |
116 | &posix_acl_default_xattr_handler, | |
ef14f0c1 | 117 | #endif |
f9e09f09 LM |
118 | NULL |
119 | }; | |
120 | ||
f7a136ae | 121 | static void |
5d92b75c | 122 | __xfs_xattr_put_listent( |
a9273ca5 | 123 | struct xfs_attr_list_context *context, |
5d92b75c AG |
124 | char *prefix, |
125 | int prefix_len, | |
126 | unsigned char *name, | |
127 | int namelen) | |
f9e09f09 | 128 | { |
f9e09f09 LM |
129 | char *offset; |
130 | int arraytop; | |
131 | ||
5d92b75c AG |
132 | if (!context->alist) |
133 | goto compute_size; | |
f9e09f09 LM |
134 | |
135 | arraytop = context->count + prefix_len + namelen + 1; | |
136 | if (arraytop > context->firstu) { | |
137 | context->count = -1; /* insufficient space */ | |
791cc43b | 138 | context->seen_enough = 1; |
f7a136ae | 139 | return; |
f9e09f09 LM |
140 | } |
141 | offset = (char *)context->alist + context->count; | |
5d92b75c | 142 | strncpy(offset, prefix, prefix_len); |
f9e09f09 | 143 | offset += prefix_len; |
a9273ca5 | 144 | strncpy(offset, (char *)name, namelen); /* real name */ |
f9e09f09 LM |
145 | offset += namelen; |
146 | *offset = '\0'; | |
5d92b75c AG |
147 | |
148 | compute_size: | |
f9e09f09 | 149 | context->count += prefix_len + namelen + 1; |
f7a136ae | 150 | return; |
f9e09f09 LM |
151 | } |
152 | ||
f7a136ae | 153 | static void |
5d92b75c | 154 | xfs_xattr_put_listent( |
a9273ca5 DC |
155 | struct xfs_attr_list_context *context, |
156 | int flags, | |
157 | unsigned char *name, | |
158 | int namelen, | |
e5bd12bf | 159 | int valuelen) |
f9e09f09 | 160 | { |
5d92b75c AG |
161 | char *prefix; |
162 | int prefix_len; | |
f9e09f09 | 163 | |
5d92b75c | 164 | ASSERT(context->count >= 0); |
f9e09f09 | 165 | |
5d92b75c AG |
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) { | |
f7a136ae | 171 | __xfs_xattr_put_listent( |
5d92b75c AG |
172 | context, XATTR_SYSTEM_PREFIX, |
173 | XATTR_SYSTEM_PREFIX_LEN, | |
174 | XATTR_POSIX_ACL_ACCESS, | |
175 | strlen(XATTR_POSIX_ACL_ACCESS)); | |
5d92b75c AG |
176 | } else if (namelen == SGI_ACL_DEFAULT_SIZE && |
177 | strncmp(name, SGI_ACL_DEFAULT, | |
178 | SGI_ACL_DEFAULT_SIZE) == 0) { | |
f7a136ae | 179 | __xfs_xattr_put_listent( |
5d92b75c AG |
180 | context, XATTR_SYSTEM_PREFIX, |
181 | XATTR_SYSTEM_PREFIX_LEN, | |
182 | XATTR_POSIX_ACL_DEFAULT, | |
183 | strlen(XATTR_POSIX_ACL_DEFAULT)); | |
5d92b75c AG |
184 | } |
185 | #endif | |
f9e09f09 | 186 | |
5d92b75c AG |
187 | /* |
188 | * Only show root namespace entries if we are actually allowed to | |
189 | * see them. | |
190 | */ | |
191 | if (!capable(CAP_SYS_ADMIN)) | |
f7a136ae | 192 | return; |
5d92b75c AG |
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; | |
202 | } | |
203 | ||
f7a136ae ES |
204 | __xfs_xattr_put_listent(context, prefix, prefix_len, name, |
205 | namelen); | |
206 | return; | |
f9e09f09 LM |
207 | } |
208 | ||
209 | ssize_t | |
2a6fba6d ES |
210 | xfs_vn_listxattr( |
211 | struct dentry *dentry, | |
212 | char *data, | |
213 | size_t size) | |
f9e09f09 LM |
214 | { |
215 | struct xfs_attr_list_context context; | |
216 | struct attrlist_cursor_kern cursor = { 0 }; | |
2a6fba6d ES |
217 | struct inode *inode = d_inode(dentry); |
218 | int error; | |
f9e09f09 LM |
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; | |
5d92b75c | 227 | context.alist = size ? data : NULL; |
f9e09f09 LM |
228 | context.bufsize = size; |
229 | context.firstu = context.bufsize; | |
5d92b75c | 230 | context.put_listent = xfs_xattr_put_listent; |
f9e09f09 | 231 | |
2a6fba6d ES |
232 | error = xfs_attr_list_int(&context); |
233 | if (error) | |
234 | return error; | |
f9e09f09 LM |
235 | if (context.count < 0) |
236 | return -ERANGE; | |
237 | ||
f9e09f09 LM |
238 | return context.count; |
239 | } |