Commit | Line | Data |
---|---|---|
0b61f8a4 | 1 | // SPDX-License-Identifier: GPL-2.0 |
ef14f0c1 CH |
2 | /* |
3 | * Copyright (c) 2008, Christoph Hellwig | |
4 | * All Rights Reserved. | |
ef14f0c1 CH |
5 | */ |
6 | #include "xfs.h" | |
5467b34b | 7 | #include "xfs_shared.h" |
a4fbe6ab | 8 | #include "xfs_format.h" |
69432832 | 9 | #include "xfs_log_format.h" |
7fd36c44 | 10 | #include "xfs_trans_resv.h" |
0a8aa193 | 11 | #include "xfs_mount.h" |
a4fbe6ab | 12 | #include "xfs_inode.h" |
e0c41089 DC |
13 | #include "xfs_da_format.h" |
14 | #include "xfs_da_btree.h" | |
a4fbe6ab | 15 | #include "xfs_attr.h" |
0b1b213f | 16 | #include "xfs_trace.h" |
a5155b87 | 17 | #include "xfs_error.h" |
5f213ddb | 18 | #include "xfs_acl.h" |
5d24ec4c | 19 | #include "xfs_trans.h" |
efc2efeb | 20 | #include "xfs_xattr.h" |
ef14f0c1 | 21 | |
5f213ddb | 22 | #include <linux/posix_acl_xattr.h> |
ef14f0c1 | 23 | |
ef14f0c1 CH |
24 | /* |
25 | * Locking scheme: | |
26 | * - all ACL updates are protected by inode->i_mutex, which is taken before | |
27 | * calling into this file. | |
ef14f0c1 CH |
28 | */ |
29 | ||
30 | STATIC struct posix_acl * | |
0a8aa193 | 31 | xfs_acl_from_disk( |
a5155b87 | 32 | struct xfs_mount *mp, |
86a21c79 AG |
33 | const struct xfs_acl *aclp, |
34 | int len, | |
35 | int max_entries) | |
ef14f0c1 CH |
36 | { |
37 | struct posix_acl_entry *acl_e; | |
38 | struct posix_acl *acl; | |
86a21c79 | 39 | const struct xfs_acl_entry *ace; |
093019cf | 40 | unsigned int count, i; |
ef14f0c1 | 41 | |
a5155b87 DW |
42 | if (len < sizeof(*aclp)) { |
43 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, aclp, | |
44 | len); | |
86a21c79 | 45 | return ERR_PTR(-EFSCORRUPTED); |
a5155b87 DW |
46 | } |
47 | ||
ef14f0c1 | 48 | count = be32_to_cpu(aclp->acl_cnt); |
a5155b87 DW |
49 | if (count > max_entries || XFS_ACL_SIZE(count) != len) { |
50 | XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, aclp, | |
51 | len); | |
fa8b18ed | 52 | return ERR_PTR(-EFSCORRUPTED); |
a5155b87 | 53 | } |
ef14f0c1 CH |
54 | |
55 | acl = posix_acl_alloc(count, GFP_KERNEL); | |
56 | if (!acl) | |
57 | return ERR_PTR(-ENOMEM); | |
58 | ||
59 | for (i = 0; i < count; i++) { | |
60 | acl_e = &acl->a_entries[i]; | |
61 | ace = &aclp->acl_entry[i]; | |
62 | ||
63 | /* | |
64 | * The tag is 32 bits on disk and 16 bits in core. | |
65 | * | |
66 | * Because every access to it goes through the core | |
67 | * format first this is not a problem. | |
68 | */ | |
69 | acl_e->e_tag = be32_to_cpu(ace->ae_tag); | |
70 | acl_e->e_perm = be16_to_cpu(ace->ae_perm); | |
71 | ||
72 | switch (acl_e->e_tag) { | |
73 | case ACL_USER: | |
ba8adad5 CH |
74 | acl_e->e_uid = make_kuid(&init_user_ns, |
75 | be32_to_cpu(ace->ae_id)); | |
288bbe0e | 76 | break; |
ef14f0c1 | 77 | case ACL_GROUP: |
ba8adad5 CH |
78 | acl_e->e_gid = make_kgid(&init_user_ns, |
79 | be32_to_cpu(ace->ae_id)); | |
ef14f0c1 CH |
80 | break; |
81 | case ACL_USER_OBJ: | |
82 | case ACL_GROUP_OBJ: | |
83 | case ACL_MASK: | |
84 | case ACL_OTHER: | |
ef14f0c1 CH |
85 | break; |
86 | default: | |
87 | goto fail; | |
88 | } | |
89 | } | |
90 | return acl; | |
91 | ||
92 | fail: | |
93 | posix_acl_release(acl); | |
94 | return ERR_PTR(-EINVAL); | |
95 | } | |
96 | ||
97 | STATIC void | |
98 | xfs_acl_to_disk(struct xfs_acl *aclp, const struct posix_acl *acl) | |
99 | { | |
100 | const struct posix_acl_entry *acl_e; | |
101 | struct xfs_acl_entry *ace; | |
102 | int i; | |
103 | ||
104 | aclp->acl_cnt = cpu_to_be32(acl->a_count); | |
105 | for (i = 0; i < acl->a_count; i++) { | |
106 | ace = &aclp->acl_entry[i]; | |
107 | acl_e = &acl->a_entries[i]; | |
108 | ||
109 | ace->ae_tag = cpu_to_be32(acl_e->e_tag); | |
288bbe0e DE |
110 | switch (acl_e->e_tag) { |
111 | case ACL_USER: | |
ba8adad5 CH |
112 | ace->ae_id = cpu_to_be32( |
113 | from_kuid(&init_user_ns, acl_e->e_uid)); | |
288bbe0e DE |
114 | break; |
115 | case ACL_GROUP: | |
ba8adad5 CH |
116 | ace->ae_id = cpu_to_be32( |
117 | from_kgid(&init_user_ns, acl_e->e_gid)); | |
288bbe0e DE |
118 | break; |
119 | default: | |
120 | ace->ae_id = cpu_to_be32(ACL_UNDEFINED_ID); | |
121 | break; | |
122 | } | |
123 | ||
ef14f0c1 CH |
124 | ace->ae_perm = cpu_to_be16(acl_e->e_perm); |
125 | } | |
126 | } | |
127 | ||
ef14f0c1 | 128 | struct posix_acl * |
0cad6246 | 129 | xfs_get_acl(struct inode *inode, int type, bool rcu) |
ef14f0c1 | 130 | { |
e5171d7e CH |
131 | struct xfs_inode *ip = XFS_I(inode); |
132 | struct xfs_mount *mp = ip->i_mount; | |
133 | struct posix_acl *acl = NULL; | |
134 | struct xfs_da_args args = { | |
135 | .dp = ip, | |
d5f0f49a | 136 | .attr_filter = XFS_ATTR_ROOT, |
e5171d7e CH |
137 | .valuelen = XFS_ACL_MAX_SIZE(mp), |
138 | }; | |
139 | int error; | |
ef14f0c1 | 140 | |
0cad6246 MS |
141 | if (rcu) |
142 | return ERR_PTR(-ECHILD); | |
143 | ||
4e34e719 CH |
144 | trace_xfs_get_acl(ip); |
145 | ||
ef14f0c1 CH |
146 | switch (type) { |
147 | case ACL_TYPE_ACCESS: | |
e5171d7e | 148 | args.name = SGI_ACL_FILE; |
ef14f0c1 CH |
149 | break; |
150 | case ACL_TYPE_DEFAULT: | |
e5171d7e | 151 | args.name = SGI_ACL_DEFAULT; |
ef14f0c1 CH |
152 | break; |
153 | default: | |
1cbd20d8 | 154 | BUG(); |
ef14f0c1 | 155 | } |
e5171d7e | 156 | args.namelen = strlen(args.name); |
ef14f0c1 | 157 | |
d49db18b CH |
158 | /* |
159 | * If the attribute doesn't exist make sure we have a negative cache | |
160 | * entry, for any other error assume it is transient. | |
161 | */ | |
e5171d7e | 162 | error = xfs_attr_get(&args); |
d49db18b | 163 | if (!error) { |
e5171d7e CH |
164 | acl = xfs_acl_from_disk(mp, args.value, args.valuelen, |
165 | XFS_ACL_MAX_ENTRIES(mp)); | |
d49db18b CH |
166 | } else if (error != -ENOATTR) { |
167 | acl = ERR_PTR(error); | |
ef14f0c1 | 168 | } |
d49db18b CH |
169 | |
170 | kmem_free(args.value); | |
ef14f0c1 CH |
171 | return acl; |
172 | } | |
173 | ||
8ba35875 JK |
174 | int |
175 | __xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type) | |
ef14f0c1 | 176 | { |
a2544622 CH |
177 | struct xfs_inode *ip = XFS_I(inode); |
178 | struct xfs_da_args args = { | |
179 | .dp = ip, | |
d5f0f49a | 180 | .attr_filter = XFS_ATTR_ROOT, |
a2544622 CH |
181 | }; |
182 | int error; | |
ef14f0c1 | 183 | |
ef14f0c1 CH |
184 | switch (type) { |
185 | case ACL_TYPE_ACCESS: | |
a2544622 | 186 | args.name = SGI_ACL_FILE; |
ef14f0c1 CH |
187 | break; |
188 | case ACL_TYPE_DEFAULT: | |
189 | if (!S_ISDIR(inode->i_mode)) | |
190 | return acl ? -EACCES : 0; | |
a2544622 | 191 | args.name = SGI_ACL_DEFAULT; |
ef14f0c1 CH |
192 | break; |
193 | default: | |
194 | return -EINVAL; | |
195 | } | |
a2544622 | 196 | args.namelen = strlen(args.name); |
ef14f0c1 CH |
197 | |
198 | if (acl) { | |
ed02d13f | 199 | args.valuelen = XFS_ACL_SIZE(acl->a_count); |
8ca79df8 | 200 | args.value = kvzalloc(args.valuelen, GFP_KERNEL); |
a2544622 | 201 | if (!args.value) |
fdd3ccee | 202 | return -ENOMEM; |
a2544622 | 203 | xfs_acl_to_disk(args.value, acl); |
ef14f0c1 CH |
204 | } |
205 | ||
efc2efeb | 206 | error = xfs_attr_change(&args); |
a2544622 | 207 | kmem_free(args.value); |
0eb81a5f CH |
208 | |
209 | /* | |
210 | * If the attribute didn't exist to start with that's fine. | |
211 | */ | |
212 | if (!acl && error == -ENOATTR) | |
213 | error = 0; | |
ef14f0c1 | 214 | if (!error) |
1cbd20d8 | 215 | set_cached_acl(inode, type, acl); |
ef14f0c1 CH |
216 | return error; |
217 | } | |
218 | ||
ef14f0c1 | 219 | static int |
5d24ec4c CH |
220 | xfs_acl_set_mode( |
221 | struct inode *inode, | |
222 | umode_t mode) | |
ef14f0c1 | 223 | { |
5d24ec4c CH |
224 | struct xfs_inode *ip = XFS_I(inode); |
225 | struct xfs_mount *mp = ip->i_mount; | |
226 | struct xfs_trans *tp; | |
227 | int error; | |
ef14f0c1 | 228 | |
5d24ec4c CH |
229 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp); |
230 | if (error) | |
231 | return error; | |
ef14f0c1 | 232 | |
5d24ec4c CH |
233 | xfs_ilock(ip, XFS_ILOCK_EXCL); |
234 | xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); | |
235 | inode->i_mode = mode; | |
236 | inode->i_ctime = current_time(inode); | |
237 | xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); | |
ef14f0c1 | 238 | |
0560f31a | 239 | if (xfs_has_wsync(mp)) |
5d24ec4c CH |
240 | xfs_trans_set_sync(tp); |
241 | return xfs_trans_commit(tp); | |
ef14f0c1 CH |
242 | } |
243 | ||
ef14f0c1 | 244 | int |
549c7297 CB |
245 | xfs_set_acl(struct user_namespace *mnt_userns, struct inode *inode, |
246 | struct posix_acl *acl, int type) | |
ef14f0c1 | 247 | { |
67f2ffe3 DC |
248 | umode_t mode; |
249 | bool set_mode = false; | |
431547b3 | 250 | int error = 0; |
ef14f0c1 | 251 | |
2401dc29 | 252 | if (!acl) |
ef14f0c1 CH |
253 | goto set_acl; |
254 | ||
4ae69fea | 255 | error = -E2BIG; |
0a8aa193 | 256 | if (acl->a_count > XFS_ACL_MAX_ENTRIES(XFS_M(inode->i_sb))) |
2401dc29 | 257 | return error; |
ef14f0c1 CH |
258 | |
259 | if (type == ACL_TYPE_ACCESS) { | |
f736d93d | 260 | error = posix_acl_update_mode(mnt_userns, inode, &mode, &acl); |
07393101 JK |
261 | if (error) |
262 | return error; | |
67f2ffe3 | 263 | set_mode = true; |
ef14f0c1 CH |
264 | } |
265 | ||
266 | set_acl: | |
67f2ffe3 DC |
267 | /* |
268 | * We set the mode after successfully updating the ACL xattr because the | |
269 | * xattr update can fail at ENOSPC and we don't want to change the mode | |
270 | * if the ACL update hasn't been applied. | |
271 | */ | |
5d24ec4c CH |
272 | error = __xfs_set_acl(inode, acl, type); |
273 | if (!error && set_mode && mode != inode->i_mode) | |
274 | error = xfs_acl_set_mode(inode, mode); | |
67f2ffe3 | 275 | return error; |
ef14f0c1 | 276 | } |
5a3930e2 CH |
277 | |
278 | /* | |
279 | * Invalidate any cached ACLs if the user has bypassed the ACL interface. | |
280 | * We don't validate the content whatsoever so it is caller responsibility to | |
281 | * provide data in valid format and ensure i_mode is consistent. | |
282 | */ | |
283 | void | |
284 | xfs_forget_acl( | |
285 | struct inode *inode, | |
286 | const char *name) | |
287 | { | |
288 | if (!strcmp(name, SGI_ACL_FILE)) | |
289 | forget_cached_acl(inode, ACL_TYPE_ACCESS); | |
290 | else if (!strcmp(name, SGI_ACL_DEFAULT)) | |
291 | forget_cached_acl(inode, ACL_TYPE_DEFAULT); | |
292 | } |