video: tegra: dc: Add quick for Vizio P series
[linux-3.10.git] / fs / posix_acl.c
1 /*
2  * linux/fs/posix_acl.c
3  *
4  *  Copyright (C) 2002 by Andreas Gruenbacher <a.gruenbacher@computer.org>
5  *
6  *  Fixes from William Schumacher incorporated on 15 March 2001.
7  *     (Reported by Charles Bertsch, <CBertsch@microtest.com>).
8  */
9
10 /*
11  *  This file contains generic functions for manipulating
12  *  POSIX 1003.1e draft standard 17 ACLs.
13  */
14
15 #include <linux/kernel.h>
16 #include <linux/slab.h>
17 #include <linux/atomic.h>
18 #include <linux/fs.h>
19 #include <linux/sched.h>
20 #include <linux/posix_acl.h>
21 #include <linux/export.h>
22
23 #include <linux/errno.h>
24
25 EXPORT_SYMBOL(posix_acl_init);
26 EXPORT_SYMBOL(posix_acl_alloc);
27 EXPORT_SYMBOL(posix_acl_valid);
28 EXPORT_SYMBOL(posix_acl_equiv_mode);
29 EXPORT_SYMBOL(posix_acl_from_mode);
30
31 /*
32  * Init a fresh posix_acl
33  */
34 void
35 posix_acl_init(struct posix_acl *acl, int count)
36 {
37         atomic_set(&acl->a_refcount, 1);
38         acl->a_count = count;
39 }
40
41 /*
42  * Allocate a new ACL with the specified number of entries.
43  */
44 struct posix_acl *
45 posix_acl_alloc(int count, gfp_t flags)
46 {
47         const size_t size = sizeof(struct posix_acl) +
48                             count * sizeof(struct posix_acl_entry);
49         struct posix_acl *acl = kmalloc(size, flags);
50         if (acl)
51                 posix_acl_init(acl, count);
52         return acl;
53 }
54
55 /*
56  * Clone an ACL.
57  */
58 static struct posix_acl *
59 posix_acl_clone(const struct posix_acl *acl, gfp_t flags)
60 {
61         struct posix_acl *clone = NULL;
62
63         if (acl) {
64                 int size = sizeof(struct posix_acl) + acl->a_count *
65                            sizeof(struct posix_acl_entry);
66                 clone = kmemdup(acl, size, flags);
67                 if (clone)
68                         atomic_set(&clone->a_refcount, 1);
69         }
70         return clone;
71 }
72
73 /*
74  * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
75  */
76 int
77 posix_acl_valid(const struct posix_acl *acl)
78 {
79         const struct posix_acl_entry *pa, *pe;
80         int state = ACL_USER_OBJ;
81         kuid_t prev_uid = INVALID_UID;
82         kgid_t prev_gid = INVALID_GID;
83         int needs_mask = 0;
84
85         FOREACH_ACL_ENTRY(pa, acl, pe) {
86                 if (pa->e_perm & ~(ACL_READ|ACL_WRITE|ACL_EXECUTE))
87                         return -EINVAL;
88                 switch (pa->e_tag) {
89                         case ACL_USER_OBJ:
90                                 if (state == ACL_USER_OBJ) {
91                                         state = ACL_USER;
92                                         break;
93                                 }
94                                 return -EINVAL;
95
96                         case ACL_USER:
97                                 if (state != ACL_USER)
98                                         return -EINVAL;
99                                 if (!uid_valid(pa->e_uid))
100                                         return -EINVAL;
101                                 if (uid_valid(prev_uid) &&
102                                     uid_lte(pa->e_uid, prev_uid))
103                                         return -EINVAL;
104                                 prev_uid = pa->e_uid;
105                                 needs_mask = 1;
106                                 break;
107
108                         case ACL_GROUP_OBJ:
109                                 if (state == ACL_USER) {
110                                         state = ACL_GROUP;
111                                         break;
112                                 }
113                                 return -EINVAL;
114
115                         case ACL_GROUP:
116                                 if (state != ACL_GROUP)
117                                         return -EINVAL;
118                                 if (!gid_valid(pa->e_gid))
119                                         return -EINVAL;
120                                 if (gid_valid(prev_gid) &&
121                                     gid_lte(pa->e_gid, prev_gid))
122                                         return -EINVAL;
123                                 prev_gid = pa->e_gid;
124                                 needs_mask = 1;
125                                 break;
126
127                         case ACL_MASK:
128                                 if (state != ACL_GROUP)
129                                         return -EINVAL;
130                                 state = ACL_OTHER;
131                                 break;
132
133                         case ACL_OTHER:
134                                 if (state == ACL_OTHER ||
135                                     (state == ACL_GROUP && !needs_mask)) {
136                                         state = 0;
137                                         break;
138                                 }
139                                 return -EINVAL;
140
141                         default:
142                                 return -EINVAL;
143                 }
144         }
145         if (state == 0)
146                 return 0;
147         return -EINVAL;
148 }
149
150 /*
151  * Returns 0 if the acl can be exactly represented in the traditional
152  * file mode permission bits, or else 1. Returns -E... on error.
153  */
154 int
155 posix_acl_equiv_mode(const struct posix_acl *acl, umode_t *mode_p)
156 {
157         const struct posix_acl_entry *pa, *pe;
158         umode_t mode = 0;
159         int not_equiv = 0;
160
161         /*
162          * A null ACL can always be presented as mode bits.
163          */
164         if (!acl)
165                 return 0;
166
167         FOREACH_ACL_ENTRY(pa, acl, pe) {
168                 switch (pa->e_tag) {
169                         case ACL_USER_OBJ:
170                                 mode |= (pa->e_perm & S_IRWXO) << 6;
171                                 break;
172                         case ACL_GROUP_OBJ:
173                                 mode |= (pa->e_perm & S_IRWXO) << 3;
174                                 break;
175                         case ACL_OTHER:
176                                 mode |= pa->e_perm & S_IRWXO;
177                                 break;
178                         case ACL_MASK:
179                                 mode = (mode & ~S_IRWXG) |
180                                        ((pa->e_perm & S_IRWXO) << 3);
181                                 not_equiv = 1;
182                                 break;
183                         case ACL_USER:
184                         case ACL_GROUP:
185                                 not_equiv = 1;
186                                 break;
187                         default:
188                                 return -EINVAL;
189                 }
190         }
191         if (mode_p)
192                 *mode_p = (*mode_p & ~S_IRWXUGO) | mode;
193         return not_equiv;
194 }
195
196 /*
197  * Create an ACL representing the file mode permission bits of an inode.
198  */
199 struct posix_acl *
200 posix_acl_from_mode(umode_t mode, gfp_t flags)
201 {
202         struct posix_acl *acl = posix_acl_alloc(3, flags);
203         if (!acl)
204                 return ERR_PTR(-ENOMEM);
205
206         acl->a_entries[0].e_tag  = ACL_USER_OBJ;
207         acl->a_entries[0].e_perm = (mode & S_IRWXU) >> 6;
208
209         acl->a_entries[1].e_tag  = ACL_GROUP_OBJ;
210         acl->a_entries[1].e_perm = (mode & S_IRWXG) >> 3;
211
212         acl->a_entries[2].e_tag  = ACL_OTHER;
213         acl->a_entries[2].e_perm = (mode & S_IRWXO);
214         return acl;
215 }
216
217 /*
218  * Return 0 if current is granted want access to the inode
219  * by the acl. Returns -E... otherwise.
220  */
221 int
222 posix_acl_permission(struct inode *inode, const struct posix_acl *acl, int want)
223 {
224         const struct posix_acl_entry *pa, *pe, *mask_obj;
225         int found = 0;
226
227         want &= MAY_READ | MAY_WRITE | MAY_EXEC | MAY_NOT_BLOCK;
228
229         FOREACH_ACL_ENTRY(pa, acl, pe) {
230                 switch(pa->e_tag) {
231                         case ACL_USER_OBJ:
232                                 /* (May have been checked already) */
233                                 if (uid_eq(inode->i_uid, current_fsuid()))
234                                         goto check_perm;
235                                 break;
236                         case ACL_USER:
237                                 if (uid_eq(pa->e_uid, current_fsuid()))
238                                         goto mask;
239                                 break;
240                         case ACL_GROUP_OBJ:
241                                 if (in_group_p(inode->i_gid)) {
242                                         found = 1;
243                                         if ((pa->e_perm & want) == want)
244                                                 goto mask;
245                                 }
246                                 break;
247                         case ACL_GROUP:
248                                 if (in_group_p(pa->e_gid)) {
249                                         found = 1;
250                                         if ((pa->e_perm & want) == want)
251                                                 goto mask;
252                                 }
253                                 break;
254                         case ACL_MASK:
255                                 break;
256                         case ACL_OTHER:
257                                 if (found)
258                                         return -EACCES;
259                                 else
260                                         goto check_perm;
261                         default:
262                                 return -EIO;
263                 }
264         }
265         return -EIO;
266
267 mask:
268         for (mask_obj = pa+1; mask_obj != pe; mask_obj++) {
269                 if (mask_obj->e_tag == ACL_MASK) {
270                         if ((pa->e_perm & mask_obj->e_perm & want) == want)
271                                 return 0;
272                         return -EACCES;
273                 }
274         }
275
276 check_perm:
277         if ((pa->e_perm & want) == want)
278                 return 0;
279         return -EACCES;
280 }
281
282 /*
283  * Modify acl when creating a new inode. The caller must ensure the acl is
284  * only referenced once.
285  *
286  * mode_p initially must contain the mode parameter to the open() / creat()
287  * system calls. All permissions that are not granted by the acl are removed.
288  * The permissions in the acl are changed to reflect the mode_p parameter.
289  */
290 static int posix_acl_create_masq(struct posix_acl *acl, umode_t *mode_p)
291 {
292         struct posix_acl_entry *pa, *pe;
293         struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL;
294         umode_t mode = *mode_p;
295         int not_equiv = 0;
296
297         /* assert(atomic_read(acl->a_refcount) == 1); */
298
299         FOREACH_ACL_ENTRY(pa, acl, pe) {
300                 switch(pa->e_tag) {
301                         case ACL_USER_OBJ:
302                                 pa->e_perm &= (mode >> 6) | ~S_IRWXO;
303                                 mode &= (pa->e_perm << 6) | ~S_IRWXU;
304                                 break;
305
306                         case ACL_USER:
307                         case ACL_GROUP:
308                                 not_equiv = 1;
309                                 break;
310
311                         case ACL_GROUP_OBJ:
312                                 group_obj = pa;
313                                 break;
314
315                         case ACL_OTHER:
316                                 pa->e_perm &= mode | ~S_IRWXO;
317                                 mode &= pa->e_perm | ~S_IRWXO;
318                                 break;
319
320                         case ACL_MASK:
321                                 mask_obj = pa;
322                                 not_equiv = 1;
323                                 break;
324
325                         default:
326                                 return -EIO;
327                 }
328         }
329
330         if (mask_obj) {
331                 mask_obj->e_perm &= (mode >> 3) | ~S_IRWXO;
332                 mode &= (mask_obj->e_perm << 3) | ~S_IRWXG;
333         } else {
334                 if (!group_obj)
335                         return -EIO;
336                 group_obj->e_perm &= (mode >> 3) | ~S_IRWXO;
337                 mode &= (group_obj->e_perm << 3) | ~S_IRWXG;
338         }
339
340         *mode_p = (*mode_p & ~S_IRWXUGO) | mode;
341         return not_equiv;
342 }
343
344 /*
345  * Modify the ACL for the chmod syscall.
346  */
347 static int posix_acl_chmod_masq(struct posix_acl *acl, umode_t mode)
348 {
349         struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL;
350         struct posix_acl_entry *pa, *pe;
351
352         /* assert(atomic_read(acl->a_refcount) == 1); */
353
354         FOREACH_ACL_ENTRY(pa, acl, pe) {
355                 switch(pa->e_tag) {
356                         case ACL_USER_OBJ:
357                                 pa->e_perm = (mode & S_IRWXU) >> 6;
358                                 break;
359
360                         case ACL_USER:
361                         case ACL_GROUP:
362                                 break;
363
364                         case ACL_GROUP_OBJ:
365                                 group_obj = pa;
366                                 break;
367
368                         case ACL_MASK:
369                                 mask_obj = pa;
370                                 break;
371
372                         case ACL_OTHER:
373                                 pa->e_perm = (mode & S_IRWXO);
374                                 break;
375
376                         default:
377                                 return -EIO;
378                 }
379         }
380
381         if (mask_obj) {
382                 mask_obj->e_perm = (mode & S_IRWXG) >> 3;
383         } else {
384                 if (!group_obj)
385                         return -EIO;
386                 group_obj->e_perm = (mode & S_IRWXG) >> 3;
387         }
388
389         return 0;
390 }
391
392 int
393 posix_acl_create(struct posix_acl **acl, gfp_t gfp, umode_t *mode_p)
394 {
395         struct posix_acl *clone = posix_acl_clone(*acl, gfp);
396         int err = -ENOMEM;
397         if (clone) {
398                 err = posix_acl_create_masq(clone, mode_p);
399                 if (err < 0) {
400                         posix_acl_release(clone);
401                         clone = NULL;
402                 }
403         }
404         posix_acl_release(*acl);
405         *acl = clone;
406         return err;
407 }
408 EXPORT_SYMBOL(posix_acl_create);
409
410 int
411 posix_acl_chmod(struct posix_acl **acl, gfp_t gfp, umode_t mode)
412 {
413         struct posix_acl *clone = posix_acl_clone(*acl, gfp);
414         int err = -ENOMEM;
415         if (clone) {
416                 err = posix_acl_chmod_masq(clone, mode);
417                 if (err) {
418                         posix_acl_release(clone);
419                         clone = NULL;
420                 }
421         }
422         posix_acl_release(*acl);
423         *acl = clone;
424         return err;
425 }
426 EXPORT_SYMBOL(posix_acl_chmod);