xref: /openbmc/linux/fs/ext4/acl.c (revision 4800cd83)
1 /*
2  * linux/fs/ext4/acl.c
3  *
4  * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
5  */
6 
7 #include <linux/init.h>
8 #include <linux/sched.h>
9 #include <linux/slab.h>
10 #include <linux/capability.h>
11 #include <linux/fs.h>
12 #include "ext4_jbd2.h"
13 #include "ext4.h"
14 #include "xattr.h"
15 #include "acl.h"
16 
17 /*
18  * Convert from filesystem to in-memory representation.
19  */
20 static struct posix_acl *
21 ext4_acl_from_disk(const void *value, size_t size)
22 {
23 	const char *end = (char *)value + size;
24 	int n, count;
25 	struct posix_acl *acl;
26 
27 	if (!value)
28 		return NULL;
29 	if (size < sizeof(ext4_acl_header))
30 		 return ERR_PTR(-EINVAL);
31 	if (((ext4_acl_header *)value)->a_version !=
32 	    cpu_to_le32(EXT4_ACL_VERSION))
33 		return ERR_PTR(-EINVAL);
34 	value = (char *)value + sizeof(ext4_acl_header);
35 	count = ext4_acl_count(size);
36 	if (count < 0)
37 		return ERR_PTR(-EINVAL);
38 	if (count == 0)
39 		return NULL;
40 	acl = posix_acl_alloc(count, GFP_NOFS);
41 	if (!acl)
42 		return ERR_PTR(-ENOMEM);
43 	for (n = 0; n < count; n++) {
44 		ext4_acl_entry *entry =
45 			(ext4_acl_entry *)value;
46 		if ((char *)value + sizeof(ext4_acl_entry_short) > end)
47 			goto fail;
48 		acl->a_entries[n].e_tag  = le16_to_cpu(entry->e_tag);
49 		acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm);
50 
51 		switch (acl->a_entries[n].e_tag) {
52 		case ACL_USER_OBJ:
53 		case ACL_GROUP_OBJ:
54 		case ACL_MASK:
55 		case ACL_OTHER:
56 			value = (char *)value +
57 				sizeof(ext4_acl_entry_short);
58 			acl->a_entries[n].e_id = ACL_UNDEFINED_ID;
59 			break;
60 
61 		case ACL_USER:
62 		case ACL_GROUP:
63 			value = (char *)value + sizeof(ext4_acl_entry);
64 			if ((char *)value > end)
65 				goto fail;
66 			acl->a_entries[n].e_id =
67 				le32_to_cpu(entry->e_id);
68 			break;
69 
70 		default:
71 			goto fail;
72 		}
73 	}
74 	if (value != end)
75 		goto fail;
76 	return acl;
77 
78 fail:
79 	posix_acl_release(acl);
80 	return ERR_PTR(-EINVAL);
81 }
82 
83 /*
84  * Convert from in-memory to filesystem representation.
85  */
86 static void *
87 ext4_acl_to_disk(const struct posix_acl *acl, size_t *size)
88 {
89 	ext4_acl_header *ext_acl;
90 	char *e;
91 	size_t n;
92 
93 	*size = ext4_acl_size(acl->a_count);
94 	ext_acl = kmalloc(sizeof(ext4_acl_header) + acl->a_count *
95 			sizeof(ext4_acl_entry), GFP_NOFS);
96 	if (!ext_acl)
97 		return ERR_PTR(-ENOMEM);
98 	ext_acl->a_version = cpu_to_le32(EXT4_ACL_VERSION);
99 	e = (char *)ext_acl + sizeof(ext4_acl_header);
100 	for (n = 0; n < acl->a_count; n++) {
101 		ext4_acl_entry *entry = (ext4_acl_entry *)e;
102 		entry->e_tag  = cpu_to_le16(acl->a_entries[n].e_tag);
103 		entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm);
104 		switch (acl->a_entries[n].e_tag) {
105 		case ACL_USER:
106 		case ACL_GROUP:
107 			entry->e_id = cpu_to_le32(acl->a_entries[n].e_id);
108 			e += sizeof(ext4_acl_entry);
109 			break;
110 
111 		case ACL_USER_OBJ:
112 		case ACL_GROUP_OBJ:
113 		case ACL_MASK:
114 		case ACL_OTHER:
115 			e += sizeof(ext4_acl_entry_short);
116 			break;
117 
118 		default:
119 			goto fail;
120 		}
121 	}
122 	return (char *)ext_acl;
123 
124 fail:
125 	kfree(ext_acl);
126 	return ERR_PTR(-EINVAL);
127 }
128 
129 /*
130  * Inode operation get_posix_acl().
131  *
132  * inode->i_mutex: don't care
133  */
134 static struct posix_acl *
135 ext4_get_acl(struct inode *inode, int type)
136 {
137 	int name_index;
138 	char *value = NULL;
139 	struct posix_acl *acl;
140 	int retval;
141 
142 	if (!test_opt(inode->i_sb, POSIX_ACL))
143 		return NULL;
144 
145 	acl = get_cached_acl(inode, type);
146 	if (acl != ACL_NOT_CACHED)
147 		return acl;
148 
149 	switch (type) {
150 	case ACL_TYPE_ACCESS:
151 		name_index = EXT4_XATTR_INDEX_POSIX_ACL_ACCESS;
152 		break;
153 	case ACL_TYPE_DEFAULT:
154 		name_index = EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT;
155 		break;
156 	default:
157 		BUG();
158 	}
159 	retval = ext4_xattr_get(inode, name_index, "", NULL, 0);
160 	if (retval > 0) {
161 		value = kmalloc(retval, GFP_NOFS);
162 		if (!value)
163 			return ERR_PTR(-ENOMEM);
164 		retval = ext4_xattr_get(inode, name_index, "", value, retval);
165 	}
166 	if (retval > 0)
167 		acl = ext4_acl_from_disk(value, retval);
168 	else if (retval == -ENODATA || retval == -ENOSYS)
169 		acl = NULL;
170 	else
171 		acl = ERR_PTR(retval);
172 	kfree(value);
173 
174 	if (!IS_ERR(acl))
175 		set_cached_acl(inode, type, acl);
176 
177 	return acl;
178 }
179 
180 /*
181  * Set the access or default ACL of an inode.
182  *
183  * inode->i_mutex: down unless called from ext4_new_inode
184  */
185 static int
186 ext4_set_acl(handle_t *handle, struct inode *inode, int type,
187 	     struct posix_acl *acl)
188 {
189 	int name_index;
190 	void *value = NULL;
191 	size_t size = 0;
192 	int error;
193 
194 	if (S_ISLNK(inode->i_mode))
195 		return -EOPNOTSUPP;
196 
197 	switch (type) {
198 	case ACL_TYPE_ACCESS:
199 		name_index = EXT4_XATTR_INDEX_POSIX_ACL_ACCESS;
200 		if (acl) {
201 			mode_t mode = inode->i_mode;
202 			error = posix_acl_equiv_mode(acl, &mode);
203 			if (error < 0)
204 				return error;
205 			else {
206 				inode->i_mode = mode;
207 				inode->i_ctime = ext4_current_time(inode);
208 				ext4_mark_inode_dirty(handle, inode);
209 				if (error == 0)
210 					acl = NULL;
211 			}
212 		}
213 		break;
214 
215 	case ACL_TYPE_DEFAULT:
216 		name_index = EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT;
217 		if (!S_ISDIR(inode->i_mode))
218 			return acl ? -EACCES : 0;
219 		break;
220 
221 	default:
222 		return -EINVAL;
223 	}
224 	if (acl) {
225 		value = ext4_acl_to_disk(acl, &size);
226 		if (IS_ERR(value))
227 			return (int)PTR_ERR(value);
228 	}
229 
230 	error = ext4_xattr_set_handle(handle, inode, name_index, "",
231 				      value, size, 0);
232 
233 	kfree(value);
234 	if (!error)
235 		set_cached_acl(inode, type, acl);
236 
237 	return error;
238 }
239 
240 int
241 ext4_check_acl(struct inode *inode, int mask, unsigned int flags)
242 {
243 	struct posix_acl *acl;
244 
245 	if (flags & IPERM_FLAG_RCU) {
246 		if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
247 			return -ECHILD;
248 		return -EAGAIN;
249 	}
250 
251 	acl = ext4_get_acl(inode, ACL_TYPE_ACCESS);
252 	if (IS_ERR(acl))
253 		return PTR_ERR(acl);
254 	if (acl) {
255 		int error = posix_acl_permission(inode, acl, mask);
256 		posix_acl_release(acl);
257 		return error;
258 	}
259 
260 	return -EAGAIN;
261 }
262 
263 /*
264  * Initialize the ACLs of a new inode. Called from ext4_new_inode.
265  *
266  * dir->i_mutex: down
267  * inode->i_mutex: up (access to inode is still exclusive)
268  */
269 int
270 ext4_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
271 {
272 	struct posix_acl *acl = NULL;
273 	int error = 0;
274 
275 	if (!S_ISLNK(inode->i_mode)) {
276 		if (test_opt(dir->i_sb, POSIX_ACL)) {
277 			acl = ext4_get_acl(dir, ACL_TYPE_DEFAULT);
278 			if (IS_ERR(acl))
279 				return PTR_ERR(acl);
280 		}
281 		if (!acl)
282 			inode->i_mode &= ~current_umask();
283 	}
284 	if (test_opt(inode->i_sb, POSIX_ACL) && acl) {
285 		struct posix_acl *clone;
286 		mode_t mode;
287 
288 		if (S_ISDIR(inode->i_mode)) {
289 			error = ext4_set_acl(handle, inode,
290 					     ACL_TYPE_DEFAULT, acl);
291 			if (error)
292 				goto cleanup;
293 		}
294 		clone = posix_acl_clone(acl, GFP_NOFS);
295 		error = -ENOMEM;
296 		if (!clone)
297 			goto cleanup;
298 
299 		mode = inode->i_mode;
300 		error = posix_acl_create_masq(clone, &mode);
301 		if (error >= 0) {
302 			inode->i_mode = mode;
303 			if (error > 0) {
304 				/* This is an extended ACL */
305 				error = ext4_set_acl(handle, inode,
306 						     ACL_TYPE_ACCESS, clone);
307 			}
308 		}
309 		posix_acl_release(clone);
310 	}
311 cleanup:
312 	posix_acl_release(acl);
313 	return error;
314 }
315 
316 /*
317  * Does chmod for an inode that may have an Access Control List. The
318  * inode->i_mode field must be updated to the desired value by the caller
319  * before calling this function.
320  * Returns 0 on success, or a negative error number.
321  *
322  * We change the ACL rather than storing some ACL entries in the file
323  * mode permission bits (which would be more efficient), because that
324  * would break once additional permissions (like  ACL_APPEND, ACL_DELETE
325  * for directories) are added. There are no more bits available in the
326  * file mode.
327  *
328  * inode->i_mutex: down
329  */
330 int
331 ext4_acl_chmod(struct inode *inode)
332 {
333 	struct posix_acl *acl, *clone;
334 	int error;
335 
336 	if (S_ISLNK(inode->i_mode))
337 		return -EOPNOTSUPP;
338 	if (!test_opt(inode->i_sb, POSIX_ACL))
339 		return 0;
340 	acl = ext4_get_acl(inode, ACL_TYPE_ACCESS);
341 	if (IS_ERR(acl) || !acl)
342 		return PTR_ERR(acl);
343 	clone = posix_acl_clone(acl, GFP_KERNEL);
344 	posix_acl_release(acl);
345 	if (!clone)
346 		return -ENOMEM;
347 	error = posix_acl_chmod_masq(clone, inode->i_mode);
348 	if (!error) {
349 		handle_t *handle;
350 		int retries = 0;
351 
352 	retry:
353 		handle = ext4_journal_start(inode,
354 				EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
355 		if (IS_ERR(handle)) {
356 			error = PTR_ERR(handle);
357 			ext4_std_error(inode->i_sb, error);
358 			goto out;
359 		}
360 		error = ext4_set_acl(handle, inode, ACL_TYPE_ACCESS, clone);
361 		ext4_journal_stop(handle);
362 		if (error == -ENOSPC &&
363 		    ext4_should_retry_alloc(inode->i_sb, &retries))
364 			goto retry;
365 	}
366 out:
367 	posix_acl_release(clone);
368 	return error;
369 }
370 
371 /*
372  * Extended attribute handlers
373  */
374 static size_t
375 ext4_xattr_list_acl_access(struct dentry *dentry, char *list, size_t list_len,
376 			   const char *name, size_t name_len, int type)
377 {
378 	const size_t size = sizeof(POSIX_ACL_XATTR_ACCESS);
379 
380 	if (!test_opt(dentry->d_sb, POSIX_ACL))
381 		return 0;
382 	if (list && size <= list_len)
383 		memcpy(list, POSIX_ACL_XATTR_ACCESS, size);
384 	return size;
385 }
386 
387 static size_t
388 ext4_xattr_list_acl_default(struct dentry *dentry, char *list, size_t list_len,
389 			    const char *name, size_t name_len, int type)
390 {
391 	const size_t size = sizeof(POSIX_ACL_XATTR_DEFAULT);
392 
393 	if (!test_opt(dentry->d_sb, POSIX_ACL))
394 		return 0;
395 	if (list && size <= list_len)
396 		memcpy(list, POSIX_ACL_XATTR_DEFAULT, size);
397 	return size;
398 }
399 
400 static int
401 ext4_xattr_get_acl(struct dentry *dentry, const char *name, void *buffer,
402 		   size_t size, int type)
403 {
404 	struct posix_acl *acl;
405 	int error;
406 
407 	if (strcmp(name, "") != 0)
408 		return -EINVAL;
409 	if (!test_opt(dentry->d_sb, POSIX_ACL))
410 		return -EOPNOTSUPP;
411 
412 	acl = ext4_get_acl(dentry->d_inode, type);
413 	if (IS_ERR(acl))
414 		return PTR_ERR(acl);
415 	if (acl == NULL)
416 		return -ENODATA;
417 	error = posix_acl_to_xattr(acl, buffer, size);
418 	posix_acl_release(acl);
419 
420 	return error;
421 }
422 
423 static int
424 ext4_xattr_set_acl(struct dentry *dentry, const char *name, const void *value,
425 		   size_t size, int flags, int type)
426 {
427 	struct inode *inode = dentry->d_inode;
428 	handle_t *handle;
429 	struct posix_acl *acl;
430 	int error, retries = 0;
431 
432 	if (strcmp(name, "") != 0)
433 		return -EINVAL;
434 	if (!test_opt(inode->i_sb, POSIX_ACL))
435 		return -EOPNOTSUPP;
436 	if (!is_owner_or_cap(inode))
437 		return -EPERM;
438 
439 	if (value) {
440 		acl = posix_acl_from_xattr(value, size);
441 		if (IS_ERR(acl))
442 			return PTR_ERR(acl);
443 		else if (acl) {
444 			error = posix_acl_valid(acl);
445 			if (error)
446 				goto release_and_out;
447 		}
448 	} else
449 		acl = NULL;
450 
451 retry:
452 	handle = ext4_journal_start(inode, EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
453 	if (IS_ERR(handle))
454 		return PTR_ERR(handle);
455 	error = ext4_set_acl(handle, inode, type, acl);
456 	ext4_journal_stop(handle);
457 	if (error == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
458 		goto retry;
459 
460 release_and_out:
461 	posix_acl_release(acl);
462 	return error;
463 }
464 
465 const struct xattr_handler ext4_xattr_acl_access_handler = {
466 	.prefix	= POSIX_ACL_XATTR_ACCESS,
467 	.flags	= ACL_TYPE_ACCESS,
468 	.list	= ext4_xattr_list_acl_access,
469 	.get	= ext4_xattr_get_acl,
470 	.set	= ext4_xattr_set_acl,
471 };
472 
473 const struct xattr_handler ext4_xattr_acl_default_handler = {
474 	.prefix	= POSIX_ACL_XATTR_DEFAULT,
475 	.flags	= ACL_TYPE_DEFAULT,
476 	.list	= ext4_xattr_list_acl_default,
477 	.get	= ext4_xattr_get_acl,
478 	.set	= ext4_xattr_set_acl,
479 };
480