Whamcloud - gitweb
*** empty log message ***
[fs/lustre-release.git] / lustre / obdclass / acl.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
30  * Use is subject to license terms.
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 #ifndef EXPORT_SYMTAB
44 # define EXPORT_SYMTAB
45 #endif
46
47 #define DEBUG_SUBSYSTEM S_SEC
48
49 #include <lustre_acl.h>
50 #include <lustre_eacl.h>
51 #include <obd_support.h>
52
53 #ifdef CONFIG_FS_POSIX_ACL
54
55 #define CFS_ACL_XATTR_VERSION POSIX_ACL_XATTR_VERSION
56
57 enum {
58         ES_UNK  = 0,    /* unknown stat */
59         ES_UNC  = 1,    /* ACL entry is not changed */
60         ES_MOD  = 2,    /* ACL entry is modified */
61         ES_ADD  = 3,    /* ACL entry is added */
62         ES_DEL  = 4     /* ACL entry is deleted */
63 };
64
65 static inline void lustre_ext_acl_le_to_cpu(ext_acl_xattr_entry *d,
66                                             ext_acl_xattr_entry *s)
67 {
68         d->e_tag        = le16_to_cpu(s->e_tag);
69         d->e_perm       = le16_to_cpu(s->e_perm);
70         d->e_id         = le32_to_cpu(s->e_id);
71         d->e_stat       = le32_to_cpu(s->e_stat);
72 }
73
74 static inline void lustre_ext_acl_cpu_to_le(ext_acl_xattr_entry *d,
75                                             ext_acl_xattr_entry *s)
76 {
77         d->e_tag        = cpu_to_le16(s->e_tag);
78         d->e_perm       = cpu_to_le16(s->e_perm);
79         d->e_id         = cpu_to_le32(s->e_id);
80         d->e_stat       = cpu_to_le32(s->e_stat);
81 }
82
83 static inline void lustre_posix_acl_le_to_cpu(posix_acl_xattr_entry *d,
84                                               posix_acl_xattr_entry *s)
85 {
86         d->e_tag        = le16_to_cpu(s->e_tag);
87         d->e_perm       = le16_to_cpu(s->e_perm);
88         d->e_id         = le32_to_cpu(s->e_id);
89 }
90
91 static inline void lustre_posix_acl_cpu_to_le(posix_acl_xattr_entry *d,
92                                               posix_acl_xattr_entry *s)
93 {
94         d->e_tag        = cpu_to_le16(s->e_tag);
95         d->e_perm       = cpu_to_le16(s->e_perm);
96         d->e_id         = cpu_to_le32(s->e_id);
97 }
98
99 /*
100  * Check permission based on POSIX ACL.
101  */
102 int lustre_posix_acl_permission(struct md_ucred *mu, struct lu_attr *la,
103                                 int want, posix_acl_xattr_entry *entry,
104                                 int count)
105 {
106         posix_acl_xattr_entry *pa, *pe, *mask_obj;
107         posix_acl_xattr_entry ae, me;
108         int found = 0;
109
110         if (count <= 0)
111                 return -EACCES;
112
113         for (pa = &entry[0], pe = &entry[count - 1]; pa <= pe; pa++) {
114                 lustre_posix_acl_le_to_cpu(&ae, pa);
115                 switch (ae.e_tag) {
116                 case ACL_USER_OBJ:
117                         /* (May have been checked already) */
118                         if (la->la_uid == mu->mu_fsuid)
119                                 goto check_perm;
120                         break;
121                 case ACL_USER:
122                         if (ae.e_id == mu->mu_fsuid)
123                                 goto mask;
124                         break;
125                 case ACL_GROUP_OBJ:
126                         if (lustre_in_group_p(mu, la->la_gid)) {
127                                 found = 1;
128                                 if ((ae.e_perm & want) == want)
129                                         goto mask;
130                         }
131                         break;
132                 case ACL_GROUP:
133                         if (lustre_in_group_p(mu, ae.e_id)) {
134                                 found = 1;
135                                 if ((ae.e_perm & want) == want)
136                                         goto mask;
137                         }
138                         break;
139                 case ACL_MASK:
140                         break;
141                 case ACL_OTHER:
142                         if (found)
143                                 return -EACCES;
144                         else
145                                 goto check_perm;
146                 default:
147                         return -EIO;
148                 }
149         }
150         return -EIO;
151
152 mask:
153         for (mask_obj = pa + 1; mask_obj <= pe; mask_obj++) {
154                 lustre_posix_acl_le_to_cpu(&me, mask_obj);
155                 if (me.e_tag == ACL_MASK) {
156                         if ((ae.e_perm & me.e_perm & want) == want)
157                                 return 0;
158
159                         return -EACCES;
160                 }
161         }
162
163 check_perm:
164         if ((ae.e_perm & want) == want)
165                 return 0;
166
167         return -EACCES;
168 }
169 EXPORT_SYMBOL(lustre_posix_acl_permission);
170
171 /*
172  * Modify the ACL for the chmod.
173  */
174 int lustre_posix_acl_chmod_masq(posix_acl_xattr_entry *entry, __u32 mode,
175                                 int count)
176 {
177         posix_acl_xattr_entry *group_obj = NULL, *mask_obj = NULL, *pa, *pe;
178
179         for (pa = &entry[0], pe = &entry[count - 1]; pa <= pe; pa++) {
180                 switch (le16_to_cpu(pa->e_tag)) {
181                 case ACL_USER_OBJ:
182                         pa->e_perm = cpu_to_le16((mode & S_IRWXU) >> 6);
183                         break;
184                 case ACL_USER:
185                 case ACL_GROUP:
186                         break;
187                 case ACL_GROUP_OBJ:
188                         group_obj = pa;
189                         break;
190                 case ACL_MASK:
191                         mask_obj = pa;
192                         break;
193                 case ACL_OTHER:
194                         pa->e_perm = cpu_to_le16(mode & S_IRWXO);
195                         break;
196                 default:
197                         return -EIO;
198                 }
199         }
200
201         if (mask_obj) {
202                 mask_obj->e_perm = cpu_to_le16((mode & S_IRWXG) >> 3);
203         } else {
204                 if (!group_obj)
205                         return -EIO;
206                 group_obj->e_perm = cpu_to_le16((mode & S_IRWXG) >> 3);
207         }
208
209         return 0;
210 }
211 EXPORT_SYMBOL(lustre_posix_acl_chmod_masq);
212
213 /*
214  * Modify acl when creating a new object.
215  */
216 int lustre_posix_acl_create_masq(posix_acl_xattr_entry *entry, __u32 *pmode,
217                                  int count)
218 {
219         posix_acl_xattr_entry *group_obj = NULL, *mask_obj = NULL, *pa, *pe;
220         posix_acl_xattr_entry ae;
221         __u32 mode = *pmode;
222         int not_equiv = 0;
223
224         for (pa = &entry[0], pe = &entry[count - 1]; pa <= pe; pa++) {
225                 lustre_posix_acl_le_to_cpu(&ae, pa);
226                 switch (ae.e_tag) {
227                 case ACL_USER_OBJ:
228                         ae.e_perm &= (mode >> 6) | ~S_IRWXO;
229                         pa->e_perm = cpu_to_le16(ae.e_perm);
230                         mode &= (ae.e_perm << 6) | ~S_IRWXU;
231                         break;
232                 case ACL_USER:
233                 case ACL_GROUP:
234                         not_equiv = 1;
235                         break;
236                 case ACL_GROUP_OBJ:
237                         group_obj = pa;
238                         break;
239                 case ACL_OTHER:
240                         ae.e_perm &= mode | ~S_IRWXO;
241                         pa->e_perm = cpu_to_le16(ae.e_perm);
242                         mode &= ae.e_perm | ~S_IRWXO;
243                         break;
244                 case ACL_MASK:
245                         mask_obj = pa;
246                         not_equiv = 1;
247                         break;
248                 default:
249                         return -EIO;
250                 }
251         }
252
253         if (mask_obj) {
254                 ae.e_perm = le16_to_cpu(mask_obj->e_perm) &
255                             ((mode >> 3) | ~S_IRWXO);
256                 mode &= (ae.e_perm << 3) | ~S_IRWXG;
257                 mask_obj->e_perm = cpu_to_le16(ae.e_perm);
258         } else {
259                 if (!group_obj)
260                         return -EIO;
261                 ae.e_perm = le16_to_cpu(group_obj->e_perm) &
262                             ((mode >> 3) | ~S_IRWXO);
263                 mode &= (ae.e_perm << 3) | ~S_IRWXG;
264                 group_obj->e_perm = cpu_to_le16(ae.e_perm);
265         }
266
267         *pmode = (*pmode & ~S_IRWXUGO) | mode;
268         return not_equiv;
269 }
270 EXPORT_SYMBOL(lustre_posix_acl_create_masq);
271
272 /* if "new_count == 0", then "new = {a_version, NULL}", NOT NULL. */
273 static int lustre_posix_acl_xattr_reduce_space(posix_acl_xattr_header **header,
274                                                int old_count, int new_count)
275 {
276         int old_size = CFS_ACL_XATTR_SIZE(old_count, posix_acl_xattr);
277         int new_size = CFS_ACL_XATTR_SIZE(new_count, posix_acl_xattr);
278         posix_acl_xattr_header *new;
279
280         if (unlikely(old_count <= new_count))
281                 return old_size;
282
283         OBD_ALLOC(new, new_size);
284         if (unlikely(new == NULL))
285                 return -ENOMEM;
286
287         memcpy(new, *header, new_size);
288         OBD_FREE(*header, old_size);
289         *header = new;
290         return new_size;
291 }
292
293 /* if "new_count == 0", then "new = {0, NULL}", NOT NULL. */
294 static int lustre_ext_acl_xattr_reduce_space(ext_acl_xattr_header **header,
295                                              int old_count)
296 {
297         int ext_count = le32_to_cpu((*header)->a_count);
298         int ext_size = CFS_ACL_XATTR_SIZE(ext_count, ext_acl_xattr);
299         int old_size = CFS_ACL_XATTR_SIZE(old_count, ext_acl_xattr);
300         ext_acl_xattr_header *new;
301
302         if (unlikely(old_count <= ext_count))
303                 return 0;
304
305         OBD_ALLOC(new, ext_size);
306         if (unlikely(new == NULL))
307                 return -ENOMEM;
308
309         memcpy(new, *header, ext_size);
310         OBD_FREE(*header, old_size);
311         *header = new;
312         return 0;
313 }
314
315 /*
316  * Generate new extended ACL based on the posix ACL.
317  */
318 ext_acl_xattr_header *
319 lustre_posix_acl_xattr_2ext(posix_acl_xattr_header *header, int size)
320 {
321         int count, i, esize;
322         ext_acl_xattr_header *new;
323         ENTRY;
324
325         if (unlikely(size < 0))
326                 RETURN(ERR_PTR(-EINVAL));
327         else if (!size)
328                 count = 0;
329         else
330                 count = CFS_ACL_XATTR_COUNT(size, posix_acl_xattr);
331         esize = CFS_ACL_XATTR_SIZE(count, ext_acl_xattr);
332         OBD_ALLOC(new, esize);
333         if (unlikely(new == NULL))
334                 RETURN(ERR_PTR(-ENOMEM));
335
336         new->a_count = cpu_to_le32(count);
337         for (i = 0; i < count; i++) {
338                 new->a_entries[i].e_tag  = header->a_entries[i].e_tag;
339                 new->a_entries[i].e_perm = header->a_entries[i].e_perm;
340                 new->a_entries[i].e_id   = header->a_entries[i].e_id;
341                 new->a_entries[i].e_stat = cpu_to_le32(ES_UNK);
342         }
343
344         RETURN(new);
345 }
346 EXPORT_SYMBOL(lustre_posix_acl_xattr_2ext);
347
348 /*
349  * Filter out the "nobody" entries in the posix ACL.
350  */
351 int lustre_posix_acl_xattr_filter(posix_acl_xattr_header *header, int size,
352                                   posix_acl_xattr_header **out)
353 {
354         int count, i, j, rc = 0;
355         __u32 id;
356         posix_acl_xattr_header *new;
357         ENTRY;
358
359         if (unlikely(size < 0))
360                 RETURN(-EINVAL);
361         else if (!size)
362                 RETURN(0);
363
364         OBD_ALLOC(new, size);
365         if (unlikely(new == NULL))
366                 RETURN(-ENOMEM);
367
368         new->a_version = cpu_to_le32(CFS_ACL_XATTR_VERSION);
369         count = CFS_ACL_XATTR_COUNT(size, posix_acl_xattr);
370         for (i = 0, j = 0; i < count; i++) {
371                 id = le32_to_cpu(header->a_entries[i].e_id);
372                 switch (le16_to_cpu(header->a_entries[i].e_tag)) {
373                 case ACL_USER_OBJ:
374                 case ACL_GROUP_OBJ:
375                 case ACL_MASK:
376                 case ACL_OTHER:
377                         if (id != ACL_UNDEFINED_ID)
378                                 GOTO(_out, rc = -EIO);
379
380                         memcpy(&new->a_entries[j++], &header->a_entries[i],
381                                sizeof(posix_acl_xattr_entry));
382                         break;
383                 case ACL_USER:
384                         if (id != NOBODY_UID)
385                                 memcpy(&new->a_entries[j++],
386                                        &header->a_entries[i],
387                                        sizeof(posix_acl_xattr_entry));
388                         break;
389                 case ACL_GROUP:
390                         if (id != NOBODY_GID)
391                                 memcpy(&new->a_entries[j++],
392                                        &header->a_entries[i],
393                                        sizeof(posix_acl_xattr_entry));
394                         break;
395                 default:
396                         GOTO(_out, rc = -EIO);
397                 }
398         }
399
400         /* free unused space. */
401         rc = lustre_posix_acl_xattr_reduce_space(&new, count, j);
402         if (rc >= 0) {
403                 size = rc;
404                 *out = new;
405                 rc = 0;
406         }
407         EXIT;
408
409 _out:
410         if (rc) {
411                 OBD_FREE(new, size);
412                 size = rc;
413         }
414         return size;
415 }
416 EXPORT_SYMBOL(lustre_posix_acl_xattr_filter);
417
418 /*
419  * Convert server-side uid/gid in the posix ACL items to the client-side ones.
420  * convert rule:
421  * @CFS_IC_NOTHING
422  *  nothing to be converted.
423  * @CFS_IC_ALL
424  *  mapped ids are converted to client-side ones,
425  *  unmapped ones are converted to "nobody".
426  * @CFS_IC_MAPPED
427  *  only mapped ids are converted to "nobody".
428  * @CFS_IC_UNMAPPED
429  *  only unmapped ids are converted to "nobody".
430  */
431 int lustre_posix_acl_xattr_id2client(struct md_ucred *mu,
432                                      struct lustre_idmap_table *t,
433                                      posix_acl_xattr_header *header,
434                                      int size, int flags)
435 {
436         int count, i;
437         __u32 id;
438         ENTRY;
439
440         if (unlikely(size < 0))
441                 RETURN(-EINVAL);
442         else if (!size)
443                 RETURN(0);
444
445         if (unlikely(flags == CFS_IC_NOTHING))
446                 RETURN(0);
447
448         count = CFS_ACL_XATTR_COUNT(size, posix_acl_xattr);
449         for (i = 0; i < count; i++) {
450                 id = le32_to_cpu(header->a_entries[i].e_id);
451                 switch (le16_to_cpu(header->a_entries[i].e_tag)) {
452                 case ACL_USER_OBJ:
453                 case ACL_GROUP_OBJ:
454                 case ACL_MASK:
455                 case ACL_OTHER:
456                         if (id != ACL_UNDEFINED_ID)
457                                 RETURN(-EIO);
458                         break;
459                 case ACL_USER:
460                         id = lustre_idmap_lookup_uid(mu, t, 1, id);
461                         if (flags == CFS_IC_ALL) {
462                                 if (id == CFS_IDMAP_NOTFOUND)
463                                         id = NOBODY_UID;
464                                 header->a_entries[i].e_id = cpu_to_le32(id);
465                         } else if (flags == CFS_IC_MAPPED) {
466                                 if (id != CFS_IDMAP_NOTFOUND)
467                                         header->a_entries[i].e_id =
468                                                         cpu_to_le32(NOBODY_UID);
469                         } else if (flags == CFS_IC_UNMAPPED) {
470                                 if (id == CFS_IDMAP_NOTFOUND)
471                                         header->a_entries[i].e_id =
472                                                         cpu_to_le32(NOBODY_UID);
473                         }
474                         break;
475                 case ACL_GROUP:
476                         id = lustre_idmap_lookup_gid(mu, t, 1, id);
477                         if (flags == CFS_IC_ALL) {
478                                 if (id == CFS_IDMAP_NOTFOUND)
479                                         id = NOBODY_GID;
480                                 header->a_entries[i].e_id = cpu_to_le32(id);
481                         } else if (flags == CFS_IC_MAPPED) {
482                                 if (id != CFS_IDMAP_NOTFOUND)
483                                         header->a_entries[i].e_id =
484                                                         cpu_to_le32(NOBODY_GID);
485                         } else if (flags == CFS_IC_UNMAPPED) {
486                                 if (id == CFS_IDMAP_NOTFOUND)
487                                         header->a_entries[i].e_id =
488                                                         cpu_to_le32(NOBODY_GID);
489                         }
490                         break;
491                  default:
492                         RETURN(-EIO);
493                 }
494         }
495     RETURN(0);
496 }
497 EXPORT_SYMBOL(lustre_posix_acl_xattr_id2client);
498
499 /*
500  * Release the posix ACL space.
501  */
502 void lustre_posix_acl_xattr_free(posix_acl_xattr_header *header, int size)
503 {
504         OBD_FREE(header, size);
505 }
506 EXPORT_SYMBOL(lustre_posix_acl_xattr_free);
507
508 /*
509  * Converts client-side uid/gid in the extended ACL items to server-side ones.
510  * convert rule:
511  *  mapped ids are converted to server-side ones,
512  *  unmapped ones cause "EPERM" error.
513  */
514 int lustre_ext_acl_xattr_id2server(struct md_ucred *mu,
515                                    struct lustre_idmap_table *t,
516                                    ext_acl_xattr_header *header)
517
518 {
519         int i, count = le32_to_cpu(header->a_count);
520         __u32 id;
521         ENTRY;
522
523         for (i = 0; i < count; i++) {
524                 id = le32_to_cpu(header->a_entries[i].e_id);
525                 switch (le16_to_cpu(header->a_entries[i].e_tag)) {
526                 case ACL_USER_OBJ:
527                 case ACL_GROUP_OBJ:
528                 case ACL_MASK:
529                 case ACL_OTHER:
530                         if (id != ACL_UNDEFINED_ID)
531                                 RETURN(-EIO);
532                         break;
533                 case ACL_USER:
534                         id = lustre_idmap_lookup_uid(mu, t, 0, id);
535                         if (id == CFS_IDMAP_NOTFOUND)
536                                 RETURN(-EPERM);
537                         else
538                                 header->a_entries[i].e_id = cpu_to_le32(id);
539                         break;
540                 case ACL_GROUP:
541                         id = lustre_idmap_lookup_gid(mu, t, 0, id);
542                         if (id == CFS_IDMAP_NOTFOUND)
543                                 RETURN(-EPERM);
544                         else
545                                 header->a_entries[i].e_id = cpu_to_le32(id);
546                         break;
547                 default:
548                         RETURN(-EIO);
549                 }
550         }
551         RETURN(0);
552 }
553 EXPORT_SYMBOL(lustre_ext_acl_xattr_id2server);
554
555 /*
556  * Release the extended ACL space.
557  */
558 void lustre_ext_acl_xattr_free(ext_acl_xattr_header *header)
559 {
560         OBD_FREE(header, CFS_ACL_XATTR_SIZE(le32_to_cpu(header->a_count), \
561                                             ext_acl_xattr));
562 }
563 EXPORT_SYMBOL(lustre_ext_acl_xattr_free);
564
565 static ext_acl_xattr_entry *
566 lustre_ext_acl_xattr_search(ext_acl_xattr_header *header,
567                             posix_acl_xattr_entry *entry, int *pos)
568 {
569         int once, start, end, i, j, count = le32_to_cpu(header->a_count);
570
571         once = 0;
572         start = *pos;
573         end = count;
574
575 again:
576         for (i = start; i < end; i++) {
577                 if (header->a_entries[i].e_tag == entry->e_tag &&
578                     header->a_entries[i].e_id == entry->e_id) {
579                         j = i;
580                         if (++i >= count)
581                                 i = 0;
582                         *pos = i;
583                         return &header->a_entries[j];
584                 }
585         }
586
587         if (!once) {
588                 once = 1;
589                 start = 0;
590                 end = *pos;
591                 goto again;
592         }
593
594         return NULL;
595 }
596
597 /*
598  * Merge the posix ACL and the extended ACL into new posix ACL.
599  */
600 int lustre_acl_xattr_merge2posix(posix_acl_xattr_header *posix_header, int size,
601                                  ext_acl_xattr_header *ext_header,
602                                  posix_acl_xattr_header **out)
603 {
604         int posix_count, posix_size, i, j;
605         int ext_count = le32_to_cpu(ext_header->a_count), pos = 0, rc = 0;
606         posix_acl_xattr_entry pe = {ACL_MASK, 0, ACL_UNDEFINED_ID};
607         posix_acl_xattr_header *new;
608         ext_acl_xattr_entry *ee, ae;
609         ENTRY;
610
611         lustre_posix_acl_cpu_to_le(&pe, &pe);
612         ee = lustre_ext_acl_xattr_search(ext_header, &pe, &pos);
613         if (ee == NULL || le32_to_cpu(ee->e_stat) == ES_DEL) {
614                 /* there are only base ACL entries at most. */
615                 posix_count = 3;
616                 posix_size = CFS_ACL_XATTR_SIZE(posix_count, posix_acl_xattr);
617                 OBD_ALLOC(new, posix_size);
618                 if (unlikely(new == NULL))
619                         RETURN(-ENOMEM);
620
621                 new->a_version = cpu_to_le32(CFS_ACL_XATTR_VERSION);
622                 for (i = 0, j = 0; i < ext_count; i++) {
623                         lustre_ext_acl_le_to_cpu(&ae,
624                                                  &ext_header->a_entries[i]);
625                         switch (ae.e_tag) {
626                         case ACL_USER_OBJ:
627                         case ACL_GROUP_OBJ:
628                         case ACL_OTHER:
629                                 if (ae.e_id != ACL_UNDEFINED_ID)
630                                         GOTO(_out, rc = -EIO);
631
632                                 if (ae.e_stat != ES_DEL) {
633                                         new->a_entries[j].e_tag =
634                                                 ext_header->a_entries[i].e_tag;
635                                         new->a_entries[j].e_perm =
636                                                 ext_header->a_entries[i].e_perm;
637                                         new->a_entries[j++].e_id =
638                                                 ext_header->a_entries[i].e_id;
639                                 }
640                                 break;
641                         case ACL_MASK:
642                         case ACL_USER:
643                         case ACL_GROUP:
644                                 if (ae.e_stat == ES_DEL)
645                                         break;
646                         default:
647                                 GOTO(_out, rc = -EIO);
648                         }
649                 }
650         } else {
651                 /* maybe there are valid ACL_USER or ACL_GROUP entries in the
652                  * original server-side ACL, they are regarded as ES_UNC stat.*/
653                 int ori_posix_count;
654
655                 if (unlikely(size < 0))
656                         RETURN(-EINVAL);
657                 else if (!size)
658                         ori_posix_count = 0;
659                 else
660                         ori_posix_count =
661                                 CFS_ACL_XATTR_COUNT(size, posix_acl_xattr);
662                 posix_count = ori_posix_count + ext_count;
663                 posix_size =
664                         CFS_ACL_XATTR_SIZE(posix_count, posix_acl_xattr);
665                 OBD_ALLOC(new, posix_size);
666                 if (unlikely(new == NULL))
667                         RETURN(-ENOMEM);
668
669                 new->a_version = cpu_to_le32(CFS_ACL_XATTR_VERSION);
670                 /* 1. process the unchanged ACL entries
671                  *    in the original server-side ACL. */
672                 pos = 0;
673                 for (i = 0, j = 0; i < ori_posix_count; i++) {
674                         ee = lustre_ext_acl_xattr_search(ext_header,
675                                         &posix_header->a_entries[i], &pos);
676                         if (ee == NULL)
677                                 memcpy(&new->a_entries[j++],
678                                        &posix_header->a_entries[i],
679                                        sizeof(posix_acl_xattr_entry));
680                 }
681
682                 /* 2. process the non-deleted entries
683                  *    from client-side extended ACL. */
684                 for (i = 0; i < ext_count; i++) {
685                         if (le16_to_cpu(ext_header->a_entries[i].e_stat) !=
686                             ES_DEL) {
687                                 new->a_entries[j].e_tag =
688                                                 ext_header->a_entries[i].e_tag;
689                                 new->a_entries[j].e_perm =
690                                                 ext_header->a_entries[i].e_perm;
691                                 new->a_entries[j++].e_id =
692                                                 ext_header->a_entries[i].e_id;
693                         }
694                 }
695         }
696
697         /* free unused space. */
698         rc = lustre_posix_acl_xattr_reduce_space(&new, posix_count, j);
699         if (rc >= 0) {
700                 posix_size = rc;
701                 *out = new;
702                 rc = 0;
703         }
704         EXIT;
705
706 _out:
707         if (rc) {
708                 OBD_FREE(new, posix_size);
709                 posix_size = rc;
710         }
711         return posix_size;
712 }
713 EXPORT_SYMBOL(lustre_acl_xattr_merge2posix);
714
715 /*
716  * Merge the posix ACL and the extended ACL into new extended ACL.
717  */
718 ext_acl_xattr_header *
719 lustre_acl_xattr_merge2ext(posix_acl_xattr_header *posix_header, int size,
720                            ext_acl_xattr_header *ext_header)
721 {
722         int ori_ext_count, posix_count, ext_count, ext_size;
723         int i, j, pos = 0, rc = 0;
724         posix_acl_xattr_entry pae;
725         ext_acl_xattr_header *new;
726         ext_acl_xattr_entry *ee, eae;
727         ENTRY;
728
729         if (unlikely(size < 0))
730                 RETURN(ERR_PTR(-EINVAL));
731         else if (!size)
732                 posix_count = 0;
733         else
734                 posix_count = CFS_ACL_XATTR_COUNT(size, posix_acl_xattr);
735         ori_ext_count = le32_to_cpu(ext_header->a_count);
736         ext_count = posix_count + ori_ext_count;
737         ext_size = CFS_ACL_XATTR_SIZE(ext_count, ext_acl_xattr);
738
739         OBD_ALLOC(new, ext_size);
740         if (unlikely(new == NULL))
741                 RETURN(ERR_PTR(-ENOMEM));
742
743         for (i = 0, j = 0; i < posix_count; i++) {
744                 lustre_posix_acl_le_to_cpu(&pae, &posix_header->a_entries[i]);
745                 switch (pae.e_tag) {
746                 case ACL_USER_OBJ:
747                 case ACL_GROUP_OBJ:
748                 case ACL_MASK:
749                 case ACL_OTHER:
750                         if (pae.e_id != ACL_UNDEFINED_ID)
751                                 GOTO(out, rc = -EIO);
752                 case ACL_USER:
753                         /* ignore "nobody" entry. */
754                         if (pae.e_id == NOBODY_UID)
755                                 break;
756
757                         new->a_entries[j].e_tag =
758                                         posix_header->a_entries[i].e_tag;
759                         new->a_entries[j].e_perm =
760                                         posix_header->a_entries[i].e_perm;
761                         new->a_entries[j].e_id =
762                                         posix_header->a_entries[i].e_id;
763                         ee = lustre_ext_acl_xattr_search(ext_header,
764                                         &posix_header->a_entries[i], &pos);
765                         if (ee) {
766                                 if (posix_header->a_entries[i].e_perm !=
767                                                                 ee->e_perm)
768                                         /* entry modified. */
769                                         ee->e_perm =
770                                         new->a_entries[j++].e_stat =
771                                                         cpu_to_le32(ES_MOD);
772                                 else
773                                         /* entry unchanged. */
774                                         ee->e_perm =
775                                         new->a_entries[j++].e_stat =
776                                                         cpu_to_le32(ES_UNC);
777                         } else {
778                                 /* new entry. */
779                                 new->a_entries[j++].e_stat =
780                                                         cpu_to_le32(ES_ADD);
781                         }
782                         break;
783                 case ACL_GROUP:
784                         /* ignore "nobody" entry. */
785                         if (pae.e_id == NOBODY_GID)
786                                 break;
787                         new->a_entries[j].e_tag =
788                                         posix_header->a_entries[i].e_tag;
789                         new->a_entries[j].e_perm =
790                                         posix_header->a_entries[i].e_perm;
791                         new->a_entries[j].e_id =
792                                         posix_header->a_entries[i].e_id;
793                         ee = lustre_ext_acl_xattr_search(ext_header,
794                                         &posix_header->a_entries[i], &pos);
795                         if (ee) {
796                                 if (posix_header->a_entries[i].e_perm !=
797                                                                 ee->e_perm)
798                                         /* entry modified. */
799                                         ee->e_perm =
800                                         new->a_entries[j++].e_stat =
801                                                         cpu_to_le32(ES_MOD);
802                                 else
803                                         /* entry unchanged. */
804                                         ee->e_perm =
805                                         new->a_entries[j++].e_stat =
806                                                         cpu_to_le32(ES_UNC);
807                         } else {
808                                 /* new entry. */
809                                 new->a_entries[j++].e_stat =
810                                                         cpu_to_le32(ES_ADD);
811                         }
812                         break;
813                 default:
814                         GOTO(out, rc = -EIO);
815                 }
816         }
817
818         /* process deleted entries. */
819         for (i = 0; i < ori_ext_count; i++) {
820                 lustre_ext_acl_le_to_cpu(&eae, &ext_header->a_entries[i]);
821                 if (eae.e_stat == ES_UNK) {
822                         /* ignore "nobody" entry. */
823                         if ((eae.e_tag == ACL_USER && eae.e_id == NOBODY_UID) ||
824                             (eae.e_tag == ACL_GROUP && eae.e_id == NOBODY_GID))
825                                 continue;
826
827                         new->a_entries[j].e_tag =
828                                                 ext_header->a_entries[i].e_tag;
829                         new->a_entries[j].e_perm =
830                                                 ext_header->a_entries[i].e_perm;
831                         new->a_entries[j].e_id = ext_header->a_entries[i].e_id;
832                         new->a_entries[j++].e_stat = cpu_to_le32(ES_DEL);
833                 }
834         }
835
836         new->a_count = cpu_to_le32(j);
837         /* free unused space. */
838         rc = lustre_ext_acl_xattr_reduce_space(&new, ext_count);
839         EXIT;
840
841 out:
842         if (rc) {
843                 OBD_FREE(new, ext_size);
844                 new = ERR_PTR(rc);
845         }
846         return new;
847 }
848 EXPORT_SYMBOL(lustre_acl_xattr_merge2ext);
849
850 #endif