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; |
ddbca70c | 115 | struct xfs_acl *xfs_acl = NULL; |
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); |
ddbca70c DC |
138 | error = xfs_attr_get(ip, ea_name, (unsigned char **)&xfs_acl, &len, |
139 | ATTR_ALLOC | ATTR_ROOT); | |
ef14f0c1 CH |
140 | if (error) { |
141 | /* | |
142 | * If the attribute doesn't exist make sure we have a negative | |
b8a7a3a6 | 143 | * cache entry, for any other error assume it is transient. |
ef14f0c1 | 144 | */ |
b8a7a3a6 AG |
145 | if (error != -ENOATTR) |
146 | acl = ERR_PTR(error); | |
147 | } else { | |
148 | acl = xfs_acl_from_disk(xfs_acl, len, | |
149 | XFS_ACL_MAX_ENTRIES(ip->i_mount)); | |
ddbca70c | 150 | kmem_free(xfs_acl); |
ef14f0c1 | 151 | } |
ef14f0c1 CH |
152 | return acl; |
153 | } | |
154 | ||
8ba35875 JK |
155 | int |
156 | __xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type) | |
ef14f0c1 CH |
157 | { |
158 | struct xfs_inode *ip = XFS_I(inode); | |
a9273ca5 | 159 | unsigned char *ea_name; |
ef14f0c1 CH |
160 | int error; |
161 | ||
ef14f0c1 CH |
162 | switch (type) { |
163 | case ACL_TYPE_ACCESS: | |
164 | ea_name = SGI_ACL_FILE; | |
ef14f0c1 CH |
165 | break; |
166 | case ACL_TYPE_DEFAULT: | |
167 | if (!S_ISDIR(inode->i_mode)) | |
168 | return acl ? -EACCES : 0; | |
169 | ea_name = SGI_ACL_DEFAULT; | |
ef14f0c1 CH |
170 | break; |
171 | default: | |
172 | return -EINVAL; | |
173 | } | |
174 | ||
175 | if (acl) { | |
176 | struct xfs_acl *xfs_acl; | |
0a8aa193 | 177 | int len = XFS_ACL_MAX_SIZE(ip->i_mount); |
ef14f0c1 | 178 | |
707e0dda | 179 | xfs_acl = kmem_zalloc_large(len, 0); |
fdd3ccee DC |
180 | if (!xfs_acl) |
181 | return -ENOMEM; | |
ef14f0c1 CH |
182 | |
183 | xfs_acl_to_disk(xfs_acl, acl); | |
0a8aa193 DC |
184 | |
185 | /* subtract away the unused acl entries */ | |
186 | len -= sizeof(struct xfs_acl_entry) * | |
187 | (XFS_ACL_MAX_ENTRIES(ip->i_mount) - acl->a_count); | |
ef14f0c1 | 188 | |
2451337d | 189 | error = xfs_attr_set(ip, ea_name, (unsigned char *)xfs_acl, |
ef14f0c1 CH |
190 | len, ATTR_ROOT); |
191 | ||
fdd3ccee | 192 | kmem_free(xfs_acl); |
ef14f0c1 CH |
193 | } else { |
194 | /* | |
195 | * A NULL ACL argument means we want to remove the ACL. | |
196 | */ | |
2451337d | 197 | error = xfs_attr_remove(ip, ea_name, ATTR_ROOT); |
ef14f0c1 CH |
198 | |
199 | /* | |
200 | * If the attribute didn't exist to start with that's fine. | |
201 | */ | |
202 | if (error == -ENOATTR) | |
203 | error = 0; | |
204 | } | |
205 | ||
206 | if (!error) | |
1cbd20d8 | 207 | set_cached_acl(inode, type, acl); |
ef14f0c1 CH |
208 | return error; |
209 | } | |
210 | ||
ef14f0c1 | 211 | static int |
d3fb6120 | 212 | xfs_set_mode(struct inode *inode, umode_t mode) |
ef14f0c1 CH |
213 | { |
214 | int error = 0; | |
215 | ||
216 | if (mode != inode->i_mode) { | |
217 | struct iattr iattr; | |
218 | ||
d6d59bad | 219 | iattr.ia_valid = ATTR_MODE | ATTR_CTIME; |
ef14f0c1 | 220 | iattr.ia_mode = mode; |
c2050a45 | 221 | iattr.ia_ctime = current_time(inode); |
ef14f0c1 | 222 | |
2451337d | 223 | error = xfs_setattr_nonsize(XFS_I(inode), &iattr, XFS_ATTR_NOACL); |
ef14f0c1 CH |
224 | } |
225 | ||
226 | return error; | |
227 | } | |
228 | ||
ef14f0c1 | 229 | int |
2401dc29 | 230 | xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type) |
ef14f0c1 | 231 | { |
67f2ffe3 DC |
232 | umode_t mode; |
233 | bool set_mode = false; | |
431547b3 | 234 | int error = 0; |
ef14f0c1 | 235 | |
2401dc29 | 236 | if (!acl) |
ef14f0c1 CH |
237 | goto set_acl; |
238 | ||
4ae69fea | 239 | error = -E2BIG; |
0a8aa193 | 240 | if (acl->a_count > XFS_ACL_MAX_ENTRIES(XFS_M(inode->i_sb))) |
2401dc29 | 241 | return error; |
ef14f0c1 CH |
242 | |
243 | if (type == ACL_TYPE_ACCESS) { | |
07393101 JK |
244 | error = posix_acl_update_mode(inode, &mode, &acl); |
245 | if (error) | |
246 | return error; | |
67f2ffe3 | 247 | set_mode = true; |
ef14f0c1 CH |
248 | } |
249 | ||
250 | set_acl: | |
67f2ffe3 DC |
251 | error = __xfs_set_acl(inode, acl, type); |
252 | if (error) | |
253 | return error; | |
254 | ||
255 | /* | |
256 | * We set the mode after successfully updating the ACL xattr because the | |
257 | * xattr update can fail at ENOSPC and we don't want to change the mode | |
258 | * if the ACL update hasn't been applied. | |
259 | */ | |
260 | if (set_mode) | |
261 | error = xfs_set_mode(inode, mode); | |
262 | ||
263 | return error; | |
ef14f0c1 | 264 | } |