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" |
ef14f0c1 CH |
15 | #include <linux/posix_acl_xattr.h> |
16 | ||
17 | ||
ef14f0c1 CH |
18 | /* |
19 | * Locking scheme: | |
20 | * - all ACL updates are protected by inode->i_mutex, which is taken before | |
21 | * calling into this file. | |
ef14f0c1 CH |
22 | */ |
23 | ||
24 | STATIC struct posix_acl * | |
0a8aa193 | 25 | xfs_acl_from_disk( |
86a21c79 AG |
26 | const struct xfs_acl *aclp, |
27 | int len, | |
28 | int max_entries) | |
ef14f0c1 CH |
29 | { |
30 | struct posix_acl_entry *acl_e; | |
31 | struct posix_acl *acl; | |
86a21c79 | 32 | const struct xfs_acl_entry *ace; |
093019cf | 33 | unsigned int count, i; |
ef14f0c1 | 34 | |
86a21c79 AG |
35 | if (len < sizeof(*aclp)) |
36 | return ERR_PTR(-EFSCORRUPTED); | |
ef14f0c1 | 37 | count = be32_to_cpu(aclp->acl_cnt); |
86a21c79 | 38 | if (count > max_entries || XFS_ACL_SIZE(count) != len) |
fa8b18ed | 39 | return ERR_PTR(-EFSCORRUPTED); |
ef14f0c1 CH |
40 | |
41 | acl = posix_acl_alloc(count, GFP_KERNEL); | |
42 | if (!acl) | |
43 | return ERR_PTR(-ENOMEM); | |
44 | ||
45 | for (i = 0; i < count; i++) { | |
46 | acl_e = &acl->a_entries[i]; | |
47 | ace = &aclp->acl_entry[i]; | |
48 | ||
49 | /* | |
50 | * The tag is 32 bits on disk and 16 bits in core. | |
51 | * | |
52 | * Because every access to it goes through the core | |
53 | * format first this is not a problem. | |
54 | */ | |
55 | acl_e->e_tag = be32_to_cpu(ace->ae_tag); | |
56 | acl_e->e_perm = be16_to_cpu(ace->ae_perm); | |
57 | ||
58 | switch (acl_e->e_tag) { | |
59 | case ACL_USER: | |
288bbe0e DE |
60 | acl_e->e_uid = xfs_uid_to_kuid(be32_to_cpu(ace->ae_id)); |
61 | break; | |
ef14f0c1 | 62 | case ACL_GROUP: |
288bbe0e | 63 | acl_e->e_gid = xfs_gid_to_kgid(be32_to_cpu(ace->ae_id)); |
ef14f0c1 CH |
64 | break; |
65 | case ACL_USER_OBJ: | |
66 | case ACL_GROUP_OBJ: | |
67 | case ACL_MASK: | |
68 | case ACL_OTHER: | |
ef14f0c1 CH |
69 | break; |
70 | default: | |
71 | goto fail; | |
72 | } | |
73 | } | |
74 | return acl; | |
75 | ||
76 | fail: | |
77 | posix_acl_release(acl); | |
78 | return ERR_PTR(-EINVAL); | |
79 | } | |
80 | ||
81 | STATIC void | |
82 | xfs_acl_to_disk(struct xfs_acl *aclp, const struct posix_acl *acl) | |
83 | { | |
84 | const struct posix_acl_entry *acl_e; | |
85 | struct xfs_acl_entry *ace; | |
86 | int i; | |
87 | ||
88 | aclp->acl_cnt = cpu_to_be32(acl->a_count); | |
89 | for (i = 0; i < acl->a_count; i++) { | |
90 | ace = &aclp->acl_entry[i]; | |
91 | acl_e = &acl->a_entries[i]; | |
92 | ||
93 | ace->ae_tag = cpu_to_be32(acl_e->e_tag); | |
288bbe0e DE |
94 | switch (acl_e->e_tag) { |
95 | case ACL_USER: | |
96 | ace->ae_id = cpu_to_be32(xfs_kuid_to_uid(acl_e->e_uid)); | |
97 | break; | |
98 | case ACL_GROUP: | |
99 | ace->ae_id = cpu_to_be32(xfs_kgid_to_gid(acl_e->e_gid)); | |
100 | break; | |
101 | default: | |
102 | ace->ae_id = cpu_to_be32(ACL_UNDEFINED_ID); | |
103 | break; | |
104 | } | |
105 | ||
ef14f0c1 CH |
106 | ace->ae_perm = cpu_to_be16(acl_e->e_perm); |
107 | } | |
108 | } | |
109 | ||
ef14f0c1 CH |
110 | struct posix_acl * |
111 | xfs_get_acl(struct inode *inode, int type) | |
112 | { | |
113 | struct xfs_inode *ip = XFS_I(inode); | |
2401dc29 | 114 | struct posix_acl *acl = NULL; |
ef14f0c1 | 115 | struct xfs_acl *xfs_acl; |
a9273ca5 | 116 | unsigned char *ea_name; |
ef14f0c1 | 117 | int error; |
0a8aa193 | 118 | int len; |
ef14f0c1 | 119 | |
4e34e719 CH |
120 | trace_xfs_get_acl(ip); |
121 | ||
ef14f0c1 CH |
122 | switch (type) { |
123 | case ACL_TYPE_ACCESS: | |
124 | ea_name = SGI_ACL_FILE; | |
ef14f0c1 CH |
125 | break; |
126 | case ACL_TYPE_DEFAULT: | |
127 | ea_name = SGI_ACL_DEFAULT; | |
ef14f0c1 CH |
128 | break; |
129 | default: | |
1cbd20d8 | 130 | BUG(); |
ef14f0c1 CH |
131 | } |
132 | ||
ef14f0c1 CH |
133 | /* |
134 | * If we have a cached ACLs value just return it, not need to | |
135 | * go out to the disk. | |
136 | */ | |
0a8aa193 | 137 | len = XFS_ACL_MAX_SIZE(ip->i_mount); |
fdd3ccee DC |
138 | xfs_acl = kmem_zalloc_large(len, KM_SLEEP); |
139 | if (!xfs_acl) | |
140 | return ERR_PTR(-ENOMEM); | |
ef14f0c1 | 141 | |
2451337d | 142 | error = xfs_attr_get(ip, ea_name, (unsigned char *)xfs_acl, |
a9273ca5 | 143 | &len, ATTR_ROOT); |
ef14f0c1 CH |
144 | if (error) { |
145 | /* | |
146 | * If the attribute doesn't exist make sure we have a negative | |
b8a7a3a6 | 147 | * cache entry, for any other error assume it is transient. |
ef14f0c1 | 148 | */ |
b8a7a3a6 AG |
149 | if (error != -ENOATTR) |
150 | acl = ERR_PTR(error); | |
151 | } else { | |
152 | acl = xfs_acl_from_disk(xfs_acl, len, | |
153 | XFS_ACL_MAX_ENTRIES(ip->i_mount)); | |
ef14f0c1 | 154 | } |
fdd3ccee | 155 | kmem_free(xfs_acl); |
ef14f0c1 CH |
156 | return acl; |
157 | } | |
158 | ||
8ba35875 JK |
159 | int |
160 | __xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type) | |
ef14f0c1 CH |
161 | { |
162 | struct xfs_inode *ip = XFS_I(inode); | |
a9273ca5 | 163 | unsigned char *ea_name; |
ef14f0c1 CH |
164 | int error; |
165 | ||
ef14f0c1 CH |
166 | switch (type) { |
167 | case ACL_TYPE_ACCESS: | |
168 | ea_name = SGI_ACL_FILE; | |
ef14f0c1 CH |
169 | break; |
170 | case ACL_TYPE_DEFAULT: | |
171 | if (!S_ISDIR(inode->i_mode)) | |
172 | return acl ? -EACCES : 0; | |
173 | ea_name = SGI_ACL_DEFAULT; | |
ef14f0c1 CH |
174 | break; |
175 | default: | |
176 | return -EINVAL; | |
177 | } | |
178 | ||
179 | if (acl) { | |
180 | struct xfs_acl *xfs_acl; | |
0a8aa193 | 181 | int len = XFS_ACL_MAX_SIZE(ip->i_mount); |
ef14f0c1 | 182 | |
fdd3ccee DC |
183 | xfs_acl = kmem_zalloc_large(len, KM_SLEEP); |
184 | if (!xfs_acl) | |
185 | return -ENOMEM; | |
ef14f0c1 CH |
186 | |
187 | xfs_acl_to_disk(xfs_acl, acl); | |
0a8aa193 DC |
188 | |
189 | /* subtract away the unused acl entries */ | |
190 | len -= sizeof(struct xfs_acl_entry) * | |
191 | (XFS_ACL_MAX_ENTRIES(ip->i_mount) - acl->a_count); | |
ef14f0c1 | 192 | |
2451337d | 193 | error = xfs_attr_set(ip, ea_name, (unsigned char *)xfs_acl, |
ef14f0c1 CH |
194 | len, ATTR_ROOT); |
195 | ||
fdd3ccee | 196 | kmem_free(xfs_acl); |
ef14f0c1 CH |
197 | } else { |
198 | /* | |
199 | * A NULL ACL argument means we want to remove the ACL. | |
200 | */ | |
2451337d | 201 | error = xfs_attr_remove(ip, ea_name, ATTR_ROOT); |
ef14f0c1 CH |
202 | |
203 | /* | |
204 | * If the attribute didn't exist to start with that's fine. | |
205 | */ | |
206 | if (error == -ENOATTR) | |
207 | error = 0; | |
208 | } | |
209 | ||
210 | if (!error) | |
1cbd20d8 | 211 | set_cached_acl(inode, type, acl); |
ef14f0c1 CH |
212 | return error; |
213 | } | |
214 | ||
ef14f0c1 | 215 | static int |
d3fb6120 | 216 | xfs_set_mode(struct inode *inode, umode_t mode) |
ef14f0c1 CH |
217 | { |
218 | int error = 0; | |
219 | ||
220 | if (mode != inode->i_mode) { | |
221 | struct iattr iattr; | |
222 | ||
d6d59bad | 223 | iattr.ia_valid = ATTR_MODE | ATTR_CTIME; |
ef14f0c1 | 224 | iattr.ia_mode = mode; |
c2050a45 | 225 | iattr.ia_ctime = current_time(inode); |
ef14f0c1 | 226 | |
2451337d | 227 | error = xfs_setattr_nonsize(XFS_I(inode), &iattr, XFS_ATTR_NOACL); |
ef14f0c1 CH |
228 | } |
229 | ||
230 | return error; | |
231 | } | |
232 | ||
ef14f0c1 | 233 | int |
2401dc29 | 234 | xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type) |
ef14f0c1 | 235 | { |
67f2ffe3 DC |
236 | umode_t mode; |
237 | bool set_mode = false; | |
431547b3 | 238 | int error = 0; |
ef14f0c1 | 239 | |
2401dc29 | 240 | if (!acl) |
ef14f0c1 CH |
241 | goto set_acl; |
242 | ||
4ae69fea | 243 | error = -E2BIG; |
0a8aa193 | 244 | if (acl->a_count > XFS_ACL_MAX_ENTRIES(XFS_M(inode->i_sb))) |
2401dc29 | 245 | return error; |
ef14f0c1 CH |
246 | |
247 | if (type == ACL_TYPE_ACCESS) { | |
07393101 JK |
248 | error = posix_acl_update_mode(inode, &mode, &acl); |
249 | if (error) | |
250 | return error; | |
67f2ffe3 | 251 | set_mode = true; |
ef14f0c1 CH |
252 | } |
253 | ||
254 | set_acl: | |
67f2ffe3 DC |
255 | error = __xfs_set_acl(inode, acl, type); |
256 | if (error) | |
257 | return error; | |
258 | ||
259 | /* | |
260 | * We set the mode after successfully updating the ACL xattr because the | |
261 | * xattr update can fail at ENOSPC and we don't want to change the mode | |
262 | * if the ACL update hasn't been applied. | |
263 | */ | |
264 | if (set_mode) | |
265 | error = xfs_set_mode(inode, mode); | |
266 | ||
267 | return error; | |
ef14f0c1 | 268 | } |