xref: /openbmc/linux/fs/f2fs/acl.c (revision 738f6ba1)
1  // SPDX-License-Identifier: GPL-2.0
2  /*
3   * fs/f2fs/acl.c
4   *
5   * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6   *             http://www.samsung.com/
7   *
8   * Portions of this code from linux/fs/ext2/acl.c
9   *
10   * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
11   */
12  #include <linux/f2fs_fs.h>
13  #include "f2fs.h"
14  #include "xattr.h"
15  #include "acl.h"
16  
17  static inline size_t f2fs_acl_size(int count)
18  {
19  	if (count <= 4) {
20  		return sizeof(struct f2fs_acl_header) +
21  			count * sizeof(struct f2fs_acl_entry_short);
22  	} else {
23  		return sizeof(struct f2fs_acl_header) +
24  			4 * sizeof(struct f2fs_acl_entry_short) +
25  			(count - 4) * sizeof(struct f2fs_acl_entry);
26  	}
27  }
28  
29  static inline int f2fs_acl_count(size_t size)
30  {
31  	ssize_t s;
32  	size -= sizeof(struct f2fs_acl_header);
33  	s = size - 4 * sizeof(struct f2fs_acl_entry_short);
34  	if (s < 0) {
35  		if (size % sizeof(struct f2fs_acl_entry_short))
36  			return -1;
37  		return size / sizeof(struct f2fs_acl_entry_short);
38  	} else {
39  		if (s % sizeof(struct f2fs_acl_entry))
40  			return -1;
41  		return s / sizeof(struct f2fs_acl_entry) + 4;
42  	}
43  }
44  
45  static struct posix_acl *f2fs_acl_from_disk(const char *value, size_t size)
46  {
47  	int i, count;
48  	struct posix_acl *acl;
49  	struct f2fs_acl_header *hdr = (struct f2fs_acl_header *)value;
50  	struct f2fs_acl_entry *entry = (struct f2fs_acl_entry *)(hdr + 1);
51  	const char *end = value + size;
52  
53  	if (size < sizeof(struct f2fs_acl_header))
54  		return ERR_PTR(-EINVAL);
55  
56  	if (hdr->a_version != cpu_to_le32(F2FS_ACL_VERSION))
57  		return ERR_PTR(-EINVAL);
58  
59  	count = f2fs_acl_count(size);
60  	if (count < 0)
61  		return ERR_PTR(-EINVAL);
62  	if (count == 0)
63  		return NULL;
64  
65  	acl = posix_acl_alloc(count, GFP_NOFS);
66  	if (!acl)
67  		return ERR_PTR(-ENOMEM);
68  
69  	for (i = 0; i < count; i++) {
70  
71  		if ((char *)entry > end)
72  			goto fail;
73  
74  		acl->a_entries[i].e_tag  = le16_to_cpu(entry->e_tag);
75  		acl->a_entries[i].e_perm = le16_to_cpu(entry->e_perm);
76  
77  		switch (acl->a_entries[i].e_tag) {
78  		case ACL_USER_OBJ:
79  		case ACL_GROUP_OBJ:
80  		case ACL_MASK:
81  		case ACL_OTHER:
82  			entry = (struct f2fs_acl_entry *)((char *)entry +
83  					sizeof(struct f2fs_acl_entry_short));
84  			break;
85  
86  		case ACL_USER:
87  			acl->a_entries[i].e_uid =
88  				make_kuid(&init_user_ns,
89  						le32_to_cpu(entry->e_id));
90  			entry = (struct f2fs_acl_entry *)((char *)entry +
91  					sizeof(struct f2fs_acl_entry));
92  			break;
93  		case ACL_GROUP:
94  			acl->a_entries[i].e_gid =
95  				make_kgid(&init_user_ns,
96  						le32_to_cpu(entry->e_id));
97  			entry = (struct f2fs_acl_entry *)((char *)entry +
98  					sizeof(struct f2fs_acl_entry));
99  			break;
100  		default:
101  			goto fail;
102  		}
103  	}
104  	if ((char *)entry != end)
105  		goto fail;
106  	return acl;
107  fail:
108  	posix_acl_release(acl);
109  	return ERR_PTR(-EINVAL);
110  }
111  
112  static void *f2fs_acl_to_disk(struct f2fs_sb_info *sbi,
113  				const struct posix_acl *acl, size_t *size)
114  {
115  	struct f2fs_acl_header *f2fs_acl;
116  	struct f2fs_acl_entry *entry;
117  	int i;
118  
119  	f2fs_acl = f2fs_kmalloc(sbi, sizeof(struct f2fs_acl_header) +
120  			acl->a_count * sizeof(struct f2fs_acl_entry),
121  			GFP_NOFS);
122  	if (!f2fs_acl)
123  		return ERR_PTR(-ENOMEM);
124  
125  	f2fs_acl->a_version = cpu_to_le32(F2FS_ACL_VERSION);
126  	entry = (struct f2fs_acl_entry *)(f2fs_acl + 1);
127  
128  	for (i = 0; i < acl->a_count; i++) {
129  
130  		entry->e_tag  = cpu_to_le16(acl->a_entries[i].e_tag);
131  		entry->e_perm = cpu_to_le16(acl->a_entries[i].e_perm);
132  
133  		switch (acl->a_entries[i].e_tag) {
134  		case ACL_USER:
135  			entry->e_id = cpu_to_le32(
136  					from_kuid(&init_user_ns,
137  						acl->a_entries[i].e_uid));
138  			entry = (struct f2fs_acl_entry *)((char *)entry +
139  					sizeof(struct f2fs_acl_entry));
140  			break;
141  		case ACL_GROUP:
142  			entry->e_id = cpu_to_le32(
143  					from_kgid(&init_user_ns,
144  						acl->a_entries[i].e_gid));
145  			entry = (struct f2fs_acl_entry *)((char *)entry +
146  					sizeof(struct f2fs_acl_entry));
147  			break;
148  		case ACL_USER_OBJ:
149  		case ACL_GROUP_OBJ:
150  		case ACL_MASK:
151  		case ACL_OTHER:
152  			entry = (struct f2fs_acl_entry *)((char *)entry +
153  					sizeof(struct f2fs_acl_entry_short));
154  			break;
155  		default:
156  			goto fail;
157  		}
158  	}
159  	*size = f2fs_acl_size(acl->a_count);
160  	return (void *)f2fs_acl;
161  
162  fail:
163  	kfree(f2fs_acl);
164  	return ERR_PTR(-EINVAL);
165  }
166  
167  static struct posix_acl *__f2fs_get_acl(struct inode *inode, int type,
168  						struct page *dpage)
169  {
170  	int name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT;
171  	void *value = NULL;
172  	struct posix_acl *acl;
173  	int retval;
174  
175  	if (type == ACL_TYPE_ACCESS)
176  		name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;
177  
178  	retval = f2fs_getxattr(inode, name_index, "", NULL, 0, dpage);
179  	if (retval > 0) {
180  		value = f2fs_kmalloc(F2FS_I_SB(inode), retval, GFP_F2FS_ZERO);
181  		if (!value)
182  			return ERR_PTR(-ENOMEM);
183  		retval = f2fs_getxattr(inode, name_index, "", value,
184  							retval, dpage);
185  	}
186  
187  	if (retval > 0)
188  		acl = f2fs_acl_from_disk(value, retval);
189  	else if (retval == -ENODATA)
190  		acl = NULL;
191  	else
192  		acl = ERR_PTR(retval);
193  	kfree(value);
194  
195  	return acl;
196  }
197  
198  struct posix_acl *f2fs_get_acl(struct inode *inode, int type)
199  {
200  	return __f2fs_get_acl(inode, type, NULL);
201  }
202  
203  static int f2fs_acl_update_mode(struct inode *inode, umode_t *mode_p,
204  			  struct posix_acl **acl)
205  {
206  	umode_t mode = inode->i_mode;
207  	int error;
208  
209  	if (is_inode_flag_set(inode, FI_ACL_MODE))
210  		mode = F2FS_I(inode)->i_acl_mode;
211  
212  	error = posix_acl_equiv_mode(*acl, &mode);
213  	if (error < 0)
214  		return error;
215  	if (error == 0)
216  		*acl = NULL;
217  	if (!in_group_p(i_gid_into_mnt(&init_user_ns, inode)) &&
218  	    !capable_wrt_inode_uidgid(&init_user_ns, inode, CAP_FSETID))
219  		mode &= ~S_ISGID;
220  	*mode_p = mode;
221  	return 0;
222  }
223  
224  static int __f2fs_set_acl(struct inode *inode, int type,
225  			struct posix_acl *acl, struct page *ipage)
226  {
227  	int name_index;
228  	void *value = NULL;
229  	size_t size = 0;
230  	int error;
231  	umode_t mode = inode->i_mode;
232  
233  	switch (type) {
234  	case ACL_TYPE_ACCESS:
235  		name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;
236  		if (acl && !ipage) {
237  			error = f2fs_acl_update_mode(inode, &mode, &acl);
238  			if (error)
239  				return error;
240  			set_acl_inode(inode, mode);
241  		}
242  		break;
243  
244  	case ACL_TYPE_DEFAULT:
245  		name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT;
246  		if (!S_ISDIR(inode->i_mode))
247  			return acl ? -EACCES : 0;
248  		break;
249  
250  	default:
251  		return -EINVAL;
252  	}
253  
254  	if (acl) {
255  		value = f2fs_acl_to_disk(F2FS_I_SB(inode), acl, &size);
256  		if (IS_ERR(value)) {
257  			clear_inode_flag(inode, FI_ACL_MODE);
258  			return PTR_ERR(value);
259  		}
260  	}
261  
262  	error = f2fs_setxattr(inode, name_index, "", value, size, ipage, 0);
263  
264  	kfree(value);
265  	if (!error)
266  		set_cached_acl(inode, type, acl);
267  
268  	clear_inode_flag(inode, FI_ACL_MODE);
269  	return error;
270  }
271  
272  int f2fs_set_acl(struct user_namespace *mnt_userns, struct inode *inode,
273  		 struct posix_acl *acl, int type)
274  {
275  	if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
276  		return -EIO;
277  
278  	return __f2fs_set_acl(inode, type, acl, NULL);
279  }
280  
281  /*
282   * Most part of f2fs_acl_clone, f2fs_acl_create_masq, f2fs_acl_create
283   * are copied from posix_acl.c
284   */
285  static struct posix_acl *f2fs_acl_clone(const struct posix_acl *acl,
286  							gfp_t flags)
287  {
288  	struct posix_acl *clone = NULL;
289  
290  	if (acl) {
291  		int size = sizeof(struct posix_acl) + acl->a_count *
292  				sizeof(struct posix_acl_entry);
293  		clone = kmemdup(acl, size, flags);
294  		if (clone)
295  			refcount_set(&clone->a_refcount, 1);
296  	}
297  	return clone;
298  }
299  
300  static int f2fs_acl_create_masq(struct posix_acl *acl, umode_t *mode_p)
301  {
302  	struct posix_acl_entry *pa, *pe;
303  	struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL;
304  	umode_t mode = *mode_p;
305  	int not_equiv = 0;
306  
307  	/* assert(atomic_read(acl->a_refcount) == 1); */
308  
309  	FOREACH_ACL_ENTRY(pa, acl, pe) {
310  		switch (pa->e_tag) {
311  		case ACL_USER_OBJ:
312  			pa->e_perm &= (mode >> 6) | ~S_IRWXO;
313  			mode &= (pa->e_perm << 6) | ~S_IRWXU;
314  			break;
315  
316  		case ACL_USER:
317  		case ACL_GROUP:
318  			not_equiv = 1;
319  			break;
320  
321  		case ACL_GROUP_OBJ:
322  			group_obj = pa;
323  			break;
324  
325  		case ACL_OTHER:
326  			pa->e_perm &= mode | ~S_IRWXO;
327  			mode &= pa->e_perm | ~S_IRWXO;
328  			break;
329  
330  		case ACL_MASK:
331  			mask_obj = pa;
332  			not_equiv = 1;
333  			break;
334  
335  		default:
336  			return -EIO;
337  		}
338  	}
339  
340  	if (mask_obj) {
341  		mask_obj->e_perm &= (mode >> 3) | ~S_IRWXO;
342  		mode &= (mask_obj->e_perm << 3) | ~S_IRWXG;
343  	} else {
344  		if (!group_obj)
345  			return -EIO;
346  		group_obj->e_perm &= (mode >> 3) | ~S_IRWXO;
347  		mode &= (group_obj->e_perm << 3) | ~S_IRWXG;
348  	}
349  
350  	*mode_p = (*mode_p & ~S_IRWXUGO) | mode;
351  	return not_equiv;
352  }
353  
354  static int f2fs_acl_create(struct inode *dir, umode_t *mode,
355  		struct posix_acl **default_acl, struct posix_acl **acl,
356  		struct page *dpage)
357  {
358  	struct posix_acl *p;
359  	struct posix_acl *clone;
360  	int ret;
361  
362  	*acl = NULL;
363  	*default_acl = NULL;
364  
365  	if (S_ISLNK(*mode) || !IS_POSIXACL(dir))
366  		return 0;
367  
368  	p = __f2fs_get_acl(dir, ACL_TYPE_DEFAULT, dpage);
369  	if (!p || p == ERR_PTR(-EOPNOTSUPP)) {
370  		*mode &= ~current_umask();
371  		return 0;
372  	}
373  	if (IS_ERR(p))
374  		return PTR_ERR(p);
375  
376  	clone = f2fs_acl_clone(p, GFP_NOFS);
377  	if (!clone) {
378  		ret = -ENOMEM;
379  		goto release_acl;
380  	}
381  
382  	ret = f2fs_acl_create_masq(clone, mode);
383  	if (ret < 0)
384  		goto release_clone;
385  
386  	if (ret == 0)
387  		posix_acl_release(clone);
388  	else
389  		*acl = clone;
390  
391  	if (!S_ISDIR(*mode))
392  		posix_acl_release(p);
393  	else
394  		*default_acl = p;
395  
396  	return 0;
397  
398  release_clone:
399  	posix_acl_release(clone);
400  release_acl:
401  	posix_acl_release(p);
402  	return ret;
403  }
404  
405  int f2fs_init_acl(struct inode *inode, struct inode *dir, struct page *ipage,
406  							struct page *dpage)
407  {
408  	struct posix_acl *default_acl = NULL, *acl = NULL;
409  	int error;
410  
411  	error = f2fs_acl_create(dir, &inode->i_mode, &default_acl, &acl, dpage);
412  	if (error)
413  		return error;
414  
415  	f2fs_mark_inode_dirty_sync(inode, true);
416  
417  	if (default_acl) {
418  		error = __f2fs_set_acl(inode, ACL_TYPE_DEFAULT, default_acl,
419  				       ipage);
420  		posix_acl_release(default_acl);
421  	} else {
422  		inode->i_default_acl = NULL;
423  	}
424  	if (acl) {
425  		if (!error)
426  			error = __f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl,
427  					       ipage);
428  		posix_acl_release(acl);
429  	} else {
430  		inode->i_acl = NULL;
431  	}
432  
433  	return error;
434  }
435