Commit | Line | Data |
---|---|---|
0a8165d7 | 1 | /* |
af48b85b JK |
2 | * fs/f2fs/acl.c |
3 | * | |
4 | * Copyright (c) 2012 Samsung Electronics Co., Ltd. | |
5 | * http://www.samsung.com/ | |
6 | * | |
7 | * Portions of this code from linux/fs/ext2/acl.c | |
8 | * | |
9 | * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de> | |
10 | * | |
11 | * This program is free software; you can redistribute it and/or modify | |
12 | * it under the terms of the GNU General Public License version 2 as | |
13 | * published by the Free Software Foundation. | |
14 | */ | |
15 | #include <linux/f2fs_fs.h> | |
16 | #include "f2fs.h" | |
17 | #include "xattr.h" | |
18 | #include "acl.h" | |
19 | ||
af48b85b JK |
20 | static inline size_t f2fs_acl_size(int count) |
21 | { | |
22 | if (count <= 4) { | |
23 | return sizeof(struct f2fs_acl_header) + | |
24 | count * sizeof(struct f2fs_acl_entry_short); | |
25 | } else { | |
26 | return sizeof(struct f2fs_acl_header) + | |
27 | 4 * sizeof(struct f2fs_acl_entry_short) + | |
28 | (count - 4) * sizeof(struct f2fs_acl_entry); | |
29 | } | |
30 | } | |
31 | ||
32 | static inline int f2fs_acl_count(size_t size) | |
33 | { | |
34 | ssize_t s; | |
35 | size -= sizeof(struct f2fs_acl_header); | |
36 | s = size - 4 * sizeof(struct f2fs_acl_entry_short); | |
37 | if (s < 0) { | |
38 | if (size % sizeof(struct f2fs_acl_entry_short)) | |
39 | return -1; | |
40 | return size / sizeof(struct f2fs_acl_entry_short); | |
41 | } else { | |
42 | if (s % sizeof(struct f2fs_acl_entry)) | |
43 | return -1; | |
44 | return s / sizeof(struct f2fs_acl_entry) + 4; | |
45 | } | |
46 | } | |
47 | ||
48 | static struct posix_acl *f2fs_acl_from_disk(const char *value, size_t size) | |
49 | { | |
50 | int i, count; | |
51 | struct posix_acl *acl; | |
52 | struct f2fs_acl_header *hdr = (struct f2fs_acl_header *)value; | |
53 | struct f2fs_acl_entry *entry = (struct f2fs_acl_entry *)(hdr + 1); | |
54 | const char *end = value + size; | |
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_KERNEL); | |
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: | |
af48b85b JK |
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(const struct posix_acl *acl, size_t *size) | |
113 | { | |
114 | struct f2fs_acl_header *f2fs_acl; | |
115 | struct f2fs_acl_entry *entry; | |
116 | int i; | |
117 | ||
118 | f2fs_acl = kmalloc(sizeof(struct f2fs_acl_header) + acl->a_count * | |
119 | sizeof(struct f2fs_acl_entry), GFP_KERNEL); | |
120 | if (!f2fs_acl) | |
121 | return ERR_PTR(-ENOMEM); | |
122 | ||
123 | f2fs_acl->a_version = cpu_to_le32(F2FS_ACL_VERSION); | |
124 | entry = (struct f2fs_acl_entry *)(f2fs_acl + 1); | |
125 | ||
126 | for (i = 0; i < acl->a_count; i++) { | |
127 | ||
128 | entry->e_tag = cpu_to_le16(acl->a_entries[i].e_tag); | |
129 | entry->e_perm = cpu_to_le16(acl->a_entries[i].e_perm); | |
130 | ||
131 | switch (acl->a_entries[i].e_tag) { | |
132 | case ACL_USER: | |
133 | entry->e_id = cpu_to_le32( | |
134 | from_kuid(&init_user_ns, | |
135 | acl->a_entries[i].e_uid)); | |
136 | entry = (struct f2fs_acl_entry *)((char *)entry + | |
137 | sizeof(struct f2fs_acl_entry)); | |
138 | break; | |
139 | case ACL_GROUP: | |
140 | entry->e_id = cpu_to_le32( | |
141 | from_kgid(&init_user_ns, | |
142 | acl->a_entries[i].e_gid)); | |
143 | entry = (struct f2fs_acl_entry *)((char *)entry + | |
144 | sizeof(struct f2fs_acl_entry)); | |
145 | break; | |
146 | case ACL_USER_OBJ: | |
147 | case ACL_GROUP_OBJ: | |
148 | case ACL_MASK: | |
149 | case ACL_OTHER: | |
150 | entry = (struct f2fs_acl_entry *)((char *)entry + | |
151 | sizeof(struct f2fs_acl_entry_short)); | |
152 | break; | |
153 | default: | |
154 | goto fail; | |
155 | } | |
156 | } | |
157 | *size = f2fs_acl_size(acl->a_count); | |
158 | return (void *)f2fs_acl; | |
159 | ||
160 | fail: | |
161 | kfree(f2fs_acl); | |
162 | return ERR_PTR(-EINVAL); | |
163 | } | |
164 | ||
165 | struct posix_acl *f2fs_get_acl(struct inode *inode, int type) | |
166 | { | |
af48b85b JK |
167 | int name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT; |
168 | void *value = NULL; | |
169 | struct posix_acl *acl; | |
170 | int retval; | |
171 | ||
af48b85b JK |
172 | if (type == ACL_TYPE_ACCESS) |
173 | name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS; | |
174 | ||
175 | retval = f2fs_getxattr(inode, name_index, "", NULL, 0); | |
176 | if (retval > 0) { | |
808a1d74 | 177 | value = kmalloc(retval, GFP_F2FS_ZERO); |
af48b85b JK |
178 | if (!value) |
179 | return ERR_PTR(-ENOMEM); | |
180 | retval = f2fs_getxattr(inode, name_index, "", value, retval); | |
181 | } | |
182 | ||
c1b75eab | 183 | if (retval > 0) |
af48b85b | 184 | acl = f2fs_acl_from_disk(value, retval); |
c1b75eab JK |
185 | else if (retval == -ENODATA) |
186 | acl = NULL; | |
187 | else | |
188 | acl = ERR_PTR(retval); | |
af48b85b | 189 | kfree(value); |
c1b75eab | 190 | |
af48b85b JK |
191 | if (!IS_ERR(acl)) |
192 | set_cached_acl(inode, type, acl); | |
193 | ||
194 | return acl; | |
195 | } | |
196 | ||
a6dda0e6 | 197 | static int __f2fs_set_acl(struct inode *inode, int type, |
2ed2d5b3 | 198 | struct posix_acl *acl, struct page *ipage) |
af48b85b | 199 | { |
af48b85b JK |
200 | struct f2fs_inode_info *fi = F2FS_I(inode); |
201 | int name_index; | |
202 | void *value = NULL; | |
203 | size_t size = 0; | |
204 | int error; | |
205 | ||
af48b85b JK |
206 | switch (type) { |
207 | case ACL_TYPE_ACCESS: | |
208 | name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS; | |
209 | if (acl) { | |
210 | error = posix_acl_equiv_mode(acl, &inode->i_mode); | |
211 | if (error < 0) | |
212 | return error; | |
213 | set_acl_inode(fi, inode->i_mode); | |
214 | if (error == 0) | |
215 | acl = NULL; | |
216 | } | |
217 | break; | |
218 | ||
219 | case ACL_TYPE_DEFAULT: | |
220 | name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT; | |
221 | if (!S_ISDIR(inode->i_mode)) | |
222 | return acl ? -EACCES : 0; | |
223 | break; | |
224 | ||
225 | default: | |
226 | return -EINVAL; | |
227 | } | |
228 | ||
229 | if (acl) { | |
230 | value = f2fs_acl_to_disk(acl, &size); | |
231 | if (IS_ERR(value)) { | |
232 | cond_clear_inode_flag(fi, FI_ACL_MODE); | |
233 | return (int)PTR_ERR(value); | |
234 | } | |
235 | } | |
236 | ||
c02745ef | 237 | error = f2fs_setxattr(inode, name_index, "", value, size, ipage, 0); |
af48b85b JK |
238 | |
239 | kfree(value); | |
240 | if (!error) | |
241 | set_cached_acl(inode, type, acl); | |
242 | ||
243 | cond_clear_inode_flag(fi, FI_ACL_MODE); | |
244 | return error; | |
245 | } | |
246 | ||
a6dda0e6 | 247 | int f2fs_set_acl(struct inode *inode, struct posix_acl *acl, int type) |
af48b85b | 248 | { |
a6dda0e6 | 249 | return __f2fs_set_acl(inode, type, acl, NULL); |
af48b85b JK |
250 | } |
251 | ||
a6dda0e6 | 252 | int f2fs_init_acl(struct inode *inode, struct inode *dir, struct page *ipage) |
af48b85b | 253 | { |
a6dda0e6 CH |
254 | struct posix_acl *default_acl, *acl; |
255 | int error = 0; | |
af48b85b | 256 | |
a6dda0e6 | 257 | error = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl); |
af48b85b JK |
258 | if (error) |
259 | return error; | |
b8b60e1a | 260 | |
a6dda0e6 CH |
261 | if (default_acl) { |
262 | error = __f2fs_set_acl(inode, ACL_TYPE_DEFAULT, default_acl, | |
263 | ipage); | |
264 | posix_acl_release(default_acl); | |
265 | } | |
266 | if (acl) { | |
267 | if (error) | |
268 | error = __f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl, | |
269 | ipage); | |
270 | posix_acl_release(acl); | |
af48b85b JK |
271 | } |
272 | ||
af48b85b JK |
273 | return error; |
274 | } |