]>
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 CH |
127 | struct posix_acl * |
128 | xfs_get_acl(struct inode *inode, int type) | |
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 | |
4e34e719 CH |
140 | trace_xfs_get_acl(ip); |
141 | ||
ef14f0c1 CH |
142 | switch (type) { |
143 | case ACL_TYPE_ACCESS: | |
e5171d7e | 144 | args.name = SGI_ACL_FILE; |
ef14f0c1 CH |
145 | break; |
146 | case ACL_TYPE_DEFAULT: | |
e5171d7e | 147 | args.name = SGI_ACL_DEFAULT; |
ef14f0c1 CH |
148 | break; |
149 | default: | |
1cbd20d8 | 150 | BUG(); |
ef14f0c1 | 151 | } |
e5171d7e | 152 | args.namelen = strlen(args.name); |
ef14f0c1 | 153 | |
d49db18b CH |
154 | /* |
155 | * If the attribute doesn't exist make sure we have a negative cache | |
156 | * entry, for any other error assume it is transient. | |
157 | */ | |
e5171d7e | 158 | error = xfs_attr_get(&args); |
d49db18b | 159 | if (!error) { |
e5171d7e CH |
160 | acl = xfs_acl_from_disk(mp, args.value, args.valuelen, |
161 | XFS_ACL_MAX_ENTRIES(mp)); | |
d49db18b CH |
162 | } else if (error != -ENOATTR) { |
163 | acl = ERR_PTR(error); | |
ef14f0c1 | 164 | } |
d49db18b CH |
165 | |
166 | kmem_free(args.value); | |
ef14f0c1 CH |
167 | return acl; |
168 | } | |
169 | ||
8ba35875 JK |
170 | int |
171 | __xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type) | |
ef14f0c1 | 172 | { |
a2544622 CH |
173 | struct xfs_inode *ip = XFS_I(inode); |
174 | struct xfs_da_args args = { | |
175 | .dp = ip, | |
d5f0f49a | 176 | .attr_filter = XFS_ATTR_ROOT, |
a2544622 CH |
177 | }; |
178 | int error; | |
ef14f0c1 | 179 | |
ef14f0c1 CH |
180 | switch (type) { |
181 | case ACL_TYPE_ACCESS: | |
a2544622 | 182 | args.name = SGI_ACL_FILE; |
ef14f0c1 CH |
183 | break; |
184 | case ACL_TYPE_DEFAULT: | |
185 | if (!S_ISDIR(inode->i_mode)) | |
186 | return acl ? -EACCES : 0; | |
a2544622 | 187 | args.name = SGI_ACL_DEFAULT; |
ef14f0c1 CH |
188 | break; |
189 | default: | |
190 | return -EINVAL; | |
191 | } | |
a2544622 | 192 | args.namelen = strlen(args.name); |
ef14f0c1 CH |
193 | |
194 | if (acl) { | |
ed02d13f | 195 | args.valuelen = XFS_ACL_SIZE(acl->a_count); |
8ca79df8 | 196 | args.value = kvzalloc(args.valuelen, GFP_KERNEL); |
a2544622 | 197 | if (!args.value) |
fdd3ccee | 198 | return -ENOMEM; |
a2544622 | 199 | xfs_acl_to_disk(args.value, acl); |
ef14f0c1 CH |
200 | } |
201 | ||
a2544622 CH |
202 | error = xfs_attr_set(&args); |
203 | kmem_free(args.value); | |
0eb81a5f CH |
204 | |
205 | /* | |
206 | * If the attribute didn't exist to start with that's fine. | |
207 | */ | |
208 | if (!acl && error == -ENOATTR) | |
209 | error = 0; | |
ef14f0c1 | 210 | if (!error) |
1cbd20d8 | 211 | set_cached_acl(inode, type, acl); |
ef14f0c1 CH |
212 | return error; |
213 | } | |
214 | ||
ef14f0c1 | 215 | static int |
5d24ec4c CH |
216 | xfs_acl_set_mode( |
217 | struct inode *inode, | |
218 | umode_t mode) | |
ef14f0c1 | 219 | { |
5d24ec4c CH |
220 | struct xfs_inode *ip = XFS_I(inode); |
221 | struct xfs_mount *mp = ip->i_mount; | |
222 | struct xfs_trans *tp; | |
223 | int error; | |
ef14f0c1 | 224 | |
5d24ec4c CH |
225 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp); |
226 | if (error) | |
227 | return error; | |
ef14f0c1 | 228 | |
5d24ec4c CH |
229 | xfs_ilock(ip, XFS_ILOCK_EXCL); |
230 | xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); | |
231 | inode->i_mode = mode; | |
232 | inode->i_ctime = current_time(inode); | |
233 | xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); | |
ef14f0c1 | 234 | |
5d24ec4c CH |
235 | if (mp->m_flags & XFS_MOUNT_WSYNC) |
236 | xfs_trans_set_sync(tp); | |
237 | return xfs_trans_commit(tp); | |
ef14f0c1 CH |
238 | } |
239 | ||
ef14f0c1 | 240 | int |
549c7297 CB |
241 | xfs_set_acl(struct user_namespace *mnt_userns, struct inode *inode, |
242 | struct posix_acl *acl, int type) | |
ef14f0c1 | 243 | { |
67f2ffe3 DC |
244 | umode_t mode; |
245 | bool set_mode = false; | |
431547b3 | 246 | int error = 0; |
ef14f0c1 | 247 | |
2401dc29 | 248 | if (!acl) |
ef14f0c1 CH |
249 | goto set_acl; |
250 | ||
4ae69fea | 251 | error = -E2BIG; |
0a8aa193 | 252 | if (acl->a_count > XFS_ACL_MAX_ENTRIES(XFS_M(inode->i_sb))) |
2401dc29 | 253 | return error; |
ef14f0c1 CH |
254 | |
255 | if (type == ACL_TYPE_ACCESS) { | |
f736d93d | 256 | error = posix_acl_update_mode(mnt_userns, inode, &mode, &acl); |
07393101 JK |
257 | if (error) |
258 | return error; | |
67f2ffe3 | 259 | set_mode = true; |
ef14f0c1 CH |
260 | } |
261 | ||
262 | set_acl: | |
67f2ffe3 DC |
263 | /* |
264 | * We set the mode after successfully updating the ACL xattr because the | |
265 | * xattr update can fail at ENOSPC and we don't want to change the mode | |
266 | * if the ACL update hasn't been applied. | |
267 | */ | |
5d24ec4c CH |
268 | error = __xfs_set_acl(inode, acl, type); |
269 | if (!error && set_mode && mode != inode->i_mode) | |
270 | error = xfs_acl_set_mode(inode, mode); | |
67f2ffe3 | 271 | return error; |
ef14f0c1 | 272 | } |
5a3930e2 CH |
273 | |
274 | /* | |
275 | * Invalidate any cached ACLs if the user has bypassed the ACL interface. | |
276 | * We don't validate the content whatsoever so it is caller responsibility to | |
277 | * provide data in valid format and ensure i_mode is consistent. | |
278 | */ | |
279 | void | |
280 | xfs_forget_acl( | |
281 | struct inode *inode, | |
282 | const char *name) | |
283 | { | |
284 | if (!strcmp(name, SGI_ACL_FILE)) | |
285 | forget_cached_acl(inode, ACL_TYPE_ACCESS); | |
286 | else if (!strcmp(name, SGI_ACL_DEFAULT)) | |
287 | forget_cached_acl(inode, ACL_TYPE_DEFAULT); | |
288 | } |