1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
8 * Portions of this code from linux/fs/ext2/acl.c
10 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
12 #include <linux/f2fs_fs.h>
17 static inline size_t f2fs_acl_size(int count
)
20 return sizeof(struct f2fs_acl_header
) +
21 count
* sizeof(struct f2fs_acl_entry_short
);
23 return sizeof(struct f2fs_acl_header
) +
24 4 * sizeof(struct f2fs_acl_entry_short
) +
25 (count
- 4) * sizeof(struct f2fs_acl_entry
);
29 static inline int f2fs_acl_count(size_t size
)
32 size
-= sizeof(struct f2fs_acl_header
);
33 s
= size
- 4 * sizeof(struct f2fs_acl_entry_short
);
35 if (size
% sizeof(struct f2fs_acl_entry_short
))
37 return size
/ sizeof(struct f2fs_acl_entry_short
);
39 if (s
% sizeof(struct f2fs_acl_entry
))
41 return s
/ sizeof(struct f2fs_acl_entry
) + 4;
45 static struct posix_acl
*f2fs_acl_from_disk(const char *value
, size_t size
)
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
;
53 if (size
< sizeof(struct f2fs_acl_header
))
54 return ERR_PTR(-EINVAL
);
56 if (hdr
->a_version
!= cpu_to_le32(F2FS_ACL_VERSION
))
57 return ERR_PTR(-EINVAL
);
59 count
= f2fs_acl_count(size
);
61 return ERR_PTR(-EINVAL
);
65 acl
= posix_acl_alloc(count
, GFP_NOFS
);
67 return ERR_PTR(-ENOMEM
);
69 for (i
= 0; i
< count
; i
++) {
71 if ((char *)entry
> end
)
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
);
77 switch (acl
->a_entries
[i
].e_tag
) {
82 entry
= (struct f2fs_acl_entry
*)((char *)entry
+
83 sizeof(struct f2fs_acl_entry_short
));
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
));
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
));
104 if ((char *)entry
!= end
)
108 posix_acl_release(acl
);
109 return ERR_PTR(-EINVAL
);
112 static void *f2fs_acl_to_disk(struct f2fs_sb_info
*sbi
,
113 const struct posix_acl
*acl
, size_t *size
)
115 struct f2fs_acl_header
*f2fs_acl
;
116 struct f2fs_acl_entry
*entry
;
119 f2fs_acl
= f2fs_kmalloc(sbi
, sizeof(struct f2fs_acl_header
) +
120 acl
->a_count
* sizeof(struct f2fs_acl_entry
),
123 return ERR_PTR(-ENOMEM
);
125 f2fs_acl
->a_version
= cpu_to_le32(F2FS_ACL_VERSION
);
126 entry
= (struct f2fs_acl_entry
*)(f2fs_acl
+ 1);
128 for (i
= 0; i
< acl
->a_count
; i
++) {
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
);
133 switch (acl
->a_entries
[i
].e_tag
) {
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
));
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
));
152 entry
= (struct f2fs_acl_entry
*)((char *)entry
+
153 sizeof(struct f2fs_acl_entry_short
));
159 *size
= f2fs_acl_size(acl
->a_count
);
160 return (void *)f2fs_acl
;
164 return ERR_PTR(-EINVAL
);
167 static struct posix_acl
*__f2fs_get_acl(struct inode
*inode
, int type
,
170 int name_index
= F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT
;
172 struct posix_acl
*acl
;
175 if (type
== ACL_TYPE_ACCESS
)
176 name_index
= F2FS_XATTR_INDEX_POSIX_ACL_ACCESS
;
178 retval
= f2fs_getxattr(inode
, name_index
, "", NULL
, 0, dpage
);
180 value
= f2fs_kmalloc(F2FS_I_SB(inode
), retval
, GFP_F2FS_ZERO
);
182 return ERR_PTR(-ENOMEM
);
183 retval
= f2fs_getxattr(inode
, name_index
, "", value
,
188 acl
= f2fs_acl_from_disk(value
, retval
);
189 else if (retval
== -ENODATA
)
192 acl
= ERR_PTR(retval
);
198 struct posix_acl
*f2fs_get_acl(struct inode
*inode
, int type
)
200 return __f2fs_get_acl(inode
, type
, NULL
);
203 static int __f2fs_set_acl(struct inode
*inode
, int type
,
204 struct posix_acl
*acl
, struct page
*ipage
)
210 umode_t mode
= inode
->i_mode
;
213 case ACL_TYPE_ACCESS
:
214 name_index
= F2FS_XATTR_INDEX_POSIX_ACL_ACCESS
;
216 error
= posix_acl_update_mode(inode
, &mode
, &acl
);
219 set_acl_inode(inode
, mode
);
223 case ACL_TYPE_DEFAULT
:
224 name_index
= F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT
;
225 if (!S_ISDIR(inode
->i_mode
))
226 return acl
? -EACCES
: 0;
234 value
= f2fs_acl_to_disk(F2FS_I_SB(inode
), acl
, &size
);
236 clear_inode_flag(inode
, FI_ACL_MODE
);
237 return PTR_ERR(value
);
241 error
= f2fs_setxattr(inode
, name_index
, "", value
, size
, ipage
, 0);
245 set_cached_acl(inode
, type
, acl
);
247 clear_inode_flag(inode
, FI_ACL_MODE
);
251 int f2fs_set_acl(struct inode
*inode
, struct posix_acl
*acl
, int type
)
253 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode
))))
256 return __f2fs_set_acl(inode
, type
, acl
, NULL
);
260 * Most part of f2fs_acl_clone, f2fs_acl_create_masq, f2fs_acl_create
261 * are copied from posix_acl.c
263 static struct posix_acl
*f2fs_acl_clone(const struct posix_acl
*acl
,
266 struct posix_acl
*clone
= NULL
;
269 int size
= sizeof(struct posix_acl
) + acl
->a_count
*
270 sizeof(struct posix_acl_entry
);
271 clone
= kmemdup(acl
, size
, flags
);
273 refcount_set(&clone
->a_refcount
, 1);
278 static int f2fs_acl_create_masq(struct posix_acl
*acl
, umode_t
*mode_p
)
280 struct posix_acl_entry
*pa
, *pe
;
281 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
282 umode_t mode
= *mode_p
;
285 /* assert(atomic_read(acl->a_refcount) == 1); */
287 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
290 pa
->e_perm
&= (mode
>> 6) | ~S_IRWXO
;
291 mode
&= (pa
->e_perm
<< 6) | ~S_IRWXU
;
304 pa
->e_perm
&= mode
| ~S_IRWXO
;
305 mode
&= pa
->e_perm
| ~S_IRWXO
;
319 mask_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
320 mode
&= (mask_obj
->e_perm
<< 3) | ~S_IRWXG
;
324 group_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
325 mode
&= (group_obj
->e_perm
<< 3) | ~S_IRWXG
;
328 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
332 static int f2fs_acl_create(struct inode
*dir
, umode_t
*mode
,
333 struct posix_acl
**default_acl
, struct posix_acl
**acl
,
337 struct posix_acl
*clone
;
343 if (S_ISLNK(*mode
) || !IS_POSIXACL(dir
))
346 p
= __f2fs_get_acl(dir
, ACL_TYPE_DEFAULT
, dpage
);
347 if (!p
|| p
== ERR_PTR(-EOPNOTSUPP
)) {
348 *mode
&= ~current_umask();
354 clone
= f2fs_acl_clone(p
, GFP_NOFS
);
360 ret
= f2fs_acl_create_masq(clone
, mode
);
365 posix_acl_release(clone
);
370 posix_acl_release(p
);
377 posix_acl_release(clone
);
379 posix_acl_release(p
);
383 int f2fs_init_acl(struct inode
*inode
, struct inode
*dir
, struct page
*ipage
,
386 struct posix_acl
*default_acl
= NULL
, *acl
= NULL
;
389 error
= f2fs_acl_create(dir
, &inode
->i_mode
, &default_acl
, &acl
, dpage
);
393 f2fs_mark_inode_dirty_sync(inode
, true);
396 error
= __f2fs_set_acl(inode
, ACL_TYPE_DEFAULT
, default_acl
,
398 posix_acl_release(default_acl
);
400 inode
->i_default_acl
= NULL
;
404 error
= __f2fs_set_acl(inode
, ACL_TYPE_ACCESS
, acl
,
406 posix_acl_release(acl
);