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