Whamcloud - gitweb
LU-7898 osd: remove unnecessary declarations
[fs/lustre-release.git] / lustre / obdclass / acl.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2012, 2013, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/obdclass/acl.c
37  *
38  * Lustre Access Control List.
39  *
40  * Author: Fan Yong <fanyong@clusterfs.com>
41  */
42
43 #define DEBUG_SUBSYSTEM S_SEC
44 #include <lu_object.h>
45 #include <lustre_acl.h>
46 #include <lustre_eacl.h>
47 #include <obd_support.h>
48 #ifdef HAVE_SERVER_SUPPORT
49 # include <lustre_idmap.h>
50 # include <md_object.h>
51 #endif /* HAVE_SERVER_SUPPORT */
52
53 #ifdef CONFIG_FS_POSIX_ACL
54
55 static inline void lustre_posix_acl_le_to_cpu(posix_acl_xattr_entry *d,
56                                               posix_acl_xattr_entry *s)
57 {
58         d->e_tag        = le16_to_cpu(s->e_tag);
59         d->e_perm       = le16_to_cpu(s->e_perm);
60         d->e_id         = le32_to_cpu(s->e_id);
61 }
62
63 /*static inline void lustre_posix_acl_cpu_to_le(posix_acl_xattr_entry *d,
64                                               posix_acl_xattr_entry *s)
65 {
66         d->e_tag        = cpu_to_le16(s->e_tag);
67         d->e_perm       = cpu_to_le16(s->e_perm);
68         d->e_id         = cpu_to_le32(s->e_id);
69 }*/
70
71 /*
72  * Check permission based on POSIX ACL.
73  */
74 int lustre_posix_acl_permission(struct lu_ucred *mu, const struct lu_attr *la,
75                                 int want, posix_acl_xattr_entry *entry,
76                                 int count)
77 {
78         posix_acl_xattr_entry *pa, *pe, *mask_obj;
79         posix_acl_xattr_entry ae, me;
80         int found = 0;
81
82         if (count <= 0)
83                 return -EACCES;
84
85         for (pa = &entry[0], pe = &entry[count - 1]; pa <= pe; pa++) {
86                 lustre_posix_acl_le_to_cpu(&ae, pa);
87                 switch (ae.e_tag) {
88                 case ACL_USER_OBJ:
89                         /* (May have been checked already) */
90                         if (la->la_uid == mu->uc_fsuid)
91                                 goto check_perm;
92                         break;
93                 case ACL_USER:
94                         if (ae.e_id == mu->uc_fsuid)
95                                 goto mask;
96                         break;
97                 case ACL_GROUP_OBJ:
98                         if (lustre_in_group_p(mu, la->la_gid)) {
99                                 found = 1;
100                                 if ((ae.e_perm & want) == want)
101                                         goto mask;
102                         }
103                         break;
104                 case ACL_GROUP:
105                         if (lustre_in_group_p(mu, ae.e_id)) {
106                                 found = 1;
107                                 if ((ae.e_perm & want) == want)
108                                         goto mask;
109                         }
110                         break;
111                 case ACL_MASK:
112                         break;
113                 case ACL_OTHER:
114                         if (found)
115                                 return -EACCES;
116                         else
117                                 goto check_perm;
118                 default:
119                         return -EIO;
120                 }
121         }
122         return -EIO;
123
124 mask:
125         for (mask_obj = pa + 1; mask_obj <= pe; mask_obj++) {
126                 lustre_posix_acl_le_to_cpu(&me, mask_obj);
127                 if (me.e_tag == ACL_MASK) {
128                         if ((ae.e_perm & me.e_perm & want) == want)
129                                 return 0;
130
131                         return -EACCES;
132                 }
133         }
134
135 check_perm:
136         if ((ae.e_perm & want) == want)
137                 return 0;
138
139         return -EACCES;
140 }
141 EXPORT_SYMBOL(lustre_posix_acl_permission);
142
143 /*
144  * Modify the ACL for the chmod.
145  */
146 int lustre_posix_acl_chmod_masq(posix_acl_xattr_entry *entry, __u32 mode,
147                                 int count)
148 {
149         posix_acl_xattr_entry *group_obj = NULL, *mask_obj = NULL, *pa, *pe;
150
151         for (pa = &entry[0], pe = &entry[count - 1]; pa <= pe; pa++) {
152                 switch (le16_to_cpu(pa->e_tag)) {
153                 case ACL_USER_OBJ:
154                         pa->e_perm = cpu_to_le16((mode & S_IRWXU) >> 6);
155                         break;
156                 case ACL_USER:
157                 case ACL_GROUP:
158                         break;
159                 case ACL_GROUP_OBJ:
160                         group_obj = pa;
161                         break;
162                 case ACL_MASK:
163                         mask_obj = pa;
164                         break;
165                 case ACL_OTHER:
166                         pa->e_perm = cpu_to_le16(mode & S_IRWXO);
167                         break;
168                 default:
169                         return -EIO;
170                 }
171         }
172
173         if (mask_obj) {
174                 mask_obj->e_perm = cpu_to_le16((mode & S_IRWXG) >> 3);
175         } else {
176                 if (!group_obj)
177                         return -EIO;
178                 group_obj->e_perm = cpu_to_le16((mode & S_IRWXG) >> 3);
179         }
180
181         return 0;
182 }
183 EXPORT_SYMBOL(lustre_posix_acl_chmod_masq);
184
185 /*
186  * Returns 0 if the acl can be exactly represented in the traditional
187  * file mode permission bits, or else 1. Returns -E... on error.
188  */
189 int
190 lustre_posix_acl_equiv_mode(posix_acl_xattr_entry *entry, mode_t *mode_p,
191                             int count)
192 {
193         posix_acl_xattr_entry *pa, *pe;
194         mode_t                 mode = 0;
195         int                    not_equiv = 0;
196
197         for (pa = &entry[0], pe = &entry[count - 1]; pa <= pe; pa++) {
198                 __u16 perm = le16_to_cpu(pa->e_perm);
199                 switch (le16_to_cpu(pa->e_tag)) {
200                         case ACL_USER_OBJ:
201                                 mode |= (perm & S_IRWXO) << 6;
202                                 break;
203                         case ACL_GROUP_OBJ:
204                                 mode |= (perm & S_IRWXO) << 3;
205                                 break;
206                         case ACL_OTHER:
207                                 mode |= perm & S_IRWXO;
208                                 break;
209                         case ACL_MASK:
210                                 mode = (mode & ~S_IRWXG) |
211                                         ((perm & S_IRWXO) << 3);
212                                 not_equiv = 1;
213                                 break;
214                         case ACL_USER:
215                         case ACL_GROUP:
216                                 not_equiv = 1;
217                                 break;
218                         default:
219                                 return -EINVAL;
220                 }
221         }
222         if (mode_p)
223                 *mode_p = (*mode_p & ~S_IRWXUGO) | mode;
224         return not_equiv;
225 }
226 EXPORT_SYMBOL(lustre_posix_acl_equiv_mode);
227
228 /*
229  * Modify acl when creating a new object.
230  */
231 int lustre_posix_acl_create_masq(posix_acl_xattr_entry *entry, __u32 *pmode,
232                                  int count)
233 {
234         posix_acl_xattr_entry *group_obj = NULL, *mask_obj = NULL, *pa, *pe;
235         posix_acl_xattr_entry ae;
236         __u32 mode = *pmode;
237         int not_equiv = 0;
238
239         for (pa = &entry[0], pe = &entry[count - 1]; pa <= pe; pa++) {
240                 lustre_posix_acl_le_to_cpu(&ae, pa);
241                 switch (ae.e_tag) {
242                 case ACL_USER_OBJ:
243                         ae.e_perm &= (mode >> 6) | ~S_IRWXO;
244                         pa->e_perm = cpu_to_le16(ae.e_perm);
245                         mode &= (ae.e_perm << 6) | ~S_IRWXU;
246                         break;
247                 case ACL_USER:
248                 case ACL_GROUP:
249                         not_equiv = 1;
250                         break;
251                 case ACL_GROUP_OBJ:
252                         group_obj = pa;
253                         break;
254                 case ACL_OTHER:
255                         ae.e_perm &= mode | ~S_IRWXO;
256                         pa->e_perm = cpu_to_le16(ae.e_perm);
257                         mode &= ae.e_perm | ~S_IRWXO;
258                         break;
259                 case ACL_MASK:
260                         mask_obj = pa;
261                         not_equiv = 1;
262                         break;
263                 default:
264                         return -EIO;
265                 }
266         }
267
268         if (mask_obj) {
269                 ae.e_perm = le16_to_cpu(mask_obj->e_perm) &
270                             ((mode >> 3) | ~S_IRWXO);
271                 mode &= (ae.e_perm << 3) | ~S_IRWXG;
272                 mask_obj->e_perm = cpu_to_le16(ae.e_perm);
273         } else {
274                 if (!group_obj)
275                         return -EIO;
276                 ae.e_perm = le16_to_cpu(group_obj->e_perm) &
277                             ((mode >> 3) | ~S_IRWXO);
278                 mode &= (ae.e_perm << 3) | ~S_IRWXG;
279                 group_obj->e_perm = cpu_to_le16(ae.e_perm);
280         }
281
282         *pmode = (*pmode & ~S_IRWXUGO) | mode;
283         return not_equiv;
284 }
285 EXPORT_SYMBOL(lustre_posix_acl_create_masq);
286 #endif