DEVEL15-linux-warning-reduction-20090318
[openafs.git] / src / afs / LINUX / osi_groups.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * Implements:
12  * setgroups (syscall)
13  * setpag
14  *
15  */
16 #include <afsconfig.h>
17 #include "afs/param.h"
18 #ifdef LINUX_KEYRING_SUPPORT
19 #include <linux/seq_file.h>
20 #endif
21
22 RCSID
23     ("$Header$");
24
25 #include "afs/sysincludes.h"
26 #include "afsincludes.h"
27 #include "afs/afs_stats.h"      /* statistics */
28 #include "afs/nfsclient.h"
29 #ifdef AFS_LINUX22_ENV
30 #include "h/smp_lock.h"
31 #endif
32
33 #ifdef AFS_LINUX26_ONEGROUP_ENV
34 #define NUMPAGGROUPS 1
35 #else
36 #define NUMPAGGROUPS 2
37 #endif
38
39 #if defined(AFS_LINUX26_ENV)
40 static int
41 afs_setgroups(cred_t **cr, struct group_info *group_info, int change_parent)
42 {
43     struct group_info *old_info;
44
45     AFS_STATCNT(afs_setgroups);
46
47     old_info = (*cr)->cr_group_info;
48     get_group_info(group_info);
49     (*cr)->cr_group_info = group_info;
50     put_group_info(old_info);
51
52     crset(*cr);
53
54 #if defined(STRUCT_TASK_STRUCT_HAS_PARENT) && !defined(STRUCT_TASK_HAS_CRED)
55     if (change_parent) {
56         old_info = current->parent->group_info;
57         get_group_info(group_info);
58         current->parent->group_info = group_info;
59         put_group_info(old_info);
60     }
61 #endif
62
63     return (0);
64 }
65 #else
66 static int
67 afs_setgroups(cred_t **cr, int ngroups, gid_t * gidset, int change_parent)
68 {
69     int ngrps;
70     int i;
71     gid_t *gp;
72
73     AFS_STATCNT(afs_setgroups);
74
75     if (ngroups > NGROUPS)
76         return EINVAL;
77
78     gp = (*cr)->cr_groups;
79     if (ngroups < NGROUPS)
80         gp[ngroups] = (gid_t) NOGROUP;
81
82     for (i = ngroups; i > 0; i--) {
83         *gp++ = *gidset++;
84     }
85
86     (*cr)->cr_ngroups = ngroups;
87     crset(*cr);
88     return (0);
89 }
90 #endif
91
92 #if defined(AFS_LINUX26_ENV)
93 static struct group_info *
94 afs_getgroups(cred_t * cr)
95 {
96     AFS_STATCNT(afs_getgroups);
97
98     get_group_info(cr->cr_group_info);
99     return cr->cr_group_info;
100 }
101 #else
102 /* Returns number of groups. And we trust groups to be large enough to
103  * hold all the groups.
104  */
105 static int
106 afs_getgroups(cred_t *cr, gid_t *groups)
107 {
108     int i;
109     int n;
110     gid_t *gp;
111
112     AFS_STATCNT(afs_getgroups);
113
114     gp = cr->cr_groups;
115     n = cr->cr_ngroups;
116
117     for (i = 0; (i < n) && (*gp != (gid_t) NOGROUP); i++)
118         *groups++ = *gp++;
119     return i;
120 }
121 #endif
122
123 #if !defined(AFS_LINUX26_ENV)
124 /* Only propogate the PAG to the parent process. Unix's propogate to 
125  * all processes sharing the cred.
126  */
127 int
128 set_pag_in_parent(int pag, int g0, int g1)
129 {
130     int i;
131 #ifdef STRUCT_TASK_STRUCT_HAS_PARENT
132     gid_t *gp = current->parent->groups;
133     int ngroups = current->parent->ngroups;
134 #else
135     gid_t *gp = current->p_pptr->groups;
136     int ngroups = current->p_pptr->ngroups;
137 #endif
138
139     if ((ngroups < 2) || (afs_get_pag_from_groups(gp[0], gp[1]) == NOPAG)) {
140         /* We will have to shift grouplist to make room for pag */
141         if (ngroups + 2 > NGROUPS) {
142             return EINVAL;
143         }
144         for (i = ngroups - 1; i >= 0; i--) {
145             gp[i + 2] = gp[i];
146         }
147         ngroups += 2;
148     }
149     gp[0] = g0;
150     gp[1] = g1;
151     if (ngroups < NGROUPS)
152         gp[ngroups] = NOGROUP;
153
154 #ifdef STRUCT_TASK_STRUCT_HAS_PARENT
155     current->parent->ngroups = ngroups;
156 #else
157     current->p_pptr->ngroups = ngroups;
158 #endif
159     return 0;
160 }
161 #endif
162
163 #if defined(AFS_LINUX26_ENV)
164 int
165 __setpag(cred_t **cr, afs_uint32 pagvalue, afs_uint32 *newpag,
166          int change_parent)
167 {
168     struct group_info *group_info;
169 #ifndef AFS_LINUX26_ONEGROUP_ENV
170     gid_t g0, g1;
171 #endif
172     struct group_info *tmp;
173     int i;
174 #ifdef AFS_LINUX26_ONEGROUP_ENV
175     int j;
176 #endif
177     int need_space = 0;
178
179     group_info = afs_getgroups(*cr);
180     if (group_info->ngroups < NUMPAGGROUPS
181         ||  afs_get_pag_from_groups(
182 #ifdef AFS_LINUX26_ONEGROUP_ENV
183             group_info
184 #else
185             GROUP_AT(group_info, 0) ,GROUP_AT(group_info, 1)
186 #endif
187                                     ) == NOPAG) 
188         /* We will have to make sure group_info is big enough for pag */
189         need_space = NUMPAGGROUPS;
190
191     tmp = groups_alloc(group_info->ngroups + need_space);
192     
193     *newpag = (pagvalue == -1 ? genpag() : pagvalue);
194 #ifdef AFS_LINUX26_ONEGROUP_ENV
195     for (i = 0, j = 0; i < group_info->ngroups; ++i) {
196         int ths = GROUP_AT(group_info, i);
197         int last = i > 0 ? GROUP_AT(group_info, i-1) : 0;
198         if ((ths >> 24) == 'A')
199             continue;
200         if (last <= *newpag && ths > *newpag) {
201            GROUP_AT(tmp, j) = *newpag;
202            j++;
203         }
204         GROUP_AT(tmp, j) = ths;
205         j++;
206     }
207     if (j != i + need_space)
208         GROUP_AT(tmp, j) = *newpag;
209 #else
210     for (i = 0; i < group_info->ngroups; ++i)
211       GROUP_AT(tmp, i + need_space) = GROUP_AT(group_info, i);
212 #endif
213     put_group_info(group_info);
214     group_info = tmp;
215
216 #ifndef AFS_LINUX26_ONEGROUP_ENV
217     afs_get_groups_from_pag(*newpag, &g0, &g1);
218     GROUP_AT(group_info, 0) = g0;
219     GROUP_AT(group_info, 1) = g1;
220 #endif
221
222     afs_setgroups(cr, group_info, change_parent);
223
224     put_group_info(group_info);
225
226     return 0;
227 }
228
229 #ifdef LINUX_KEYRING_SUPPORT
230 extern struct key_type key_type_keyring __attribute__((weak));
231 static struct key_type *__key_type_keyring = &key_type_keyring;
232
233 static int
234 install_session_keyring(struct task_struct *task, struct key *keyring)
235 {
236     struct key *old;
237     char desc[20];
238     unsigned long not_in_quota;
239     int code = -EINVAL;
240
241     if (!__key_type_keyring)
242         return code;
243
244     if (!keyring) {
245
246         /* create an empty session keyring */
247         not_in_quota = KEY_ALLOC_IN_QUOTA;
248         sprintf(desc, "_ses.%u", task->tgid);
249
250 #ifdef KEY_ALLOC_NEEDS_STRUCT_TASK
251         keyring = key_alloc(__key_type_keyring, desc,
252                             task_uid(task), task_gid(task), task,
253                             (KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_ALL,
254                             not_in_quota);
255 #else
256         keyring = key_alloc(__key_type_keyring, desc,
257                             task_uid(task), task_gid(task),
258                             (KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_ALL,
259                             not_in_quota);
260 #endif
261         if (IS_ERR(keyring)) {
262             code = PTR_ERR(keyring);
263             goto out;
264         }
265     }
266
267     code = key_instantiate_and_link(keyring, NULL, 0, NULL, NULL);
268     if (code < 0) {
269         key_put(keyring);
270         goto out;
271     }
272
273     /* install the keyring */
274     spin_lock_irq(&task->sighand->siglock);
275     old = task_session_keyring(task);
276     smp_wmb();
277     task_session_keyring(task) = keyring;
278     spin_unlock_irq(&task->sighand->siglock);
279
280     if (old)
281             key_put(old);
282
283 out:
284     return code;
285 }
286 #endif /* LINUX_KEYRING_SUPPORT */
287
288 #else
289 int
290 __setpag(cred_t **cr, afs_uint32 pagvalue, afs_uint32 *newpag,
291          int change_parent)
292 {
293     gid_t *gidset;
294     afs_int32 ngroups, code = 0;
295     int j;
296
297     gidset = (gid_t *) osi_Alloc(NGROUPS * sizeof(gidset[0]));
298     ngroups = afs_getgroups(*cr, gidset);
299
300     if (afs_get_pag_from_groups(gidset[0], gidset[1]) == NOPAG) {
301         /* We will have to shift grouplist to make room for pag */
302         if (ngroups + 2 > NGROUPS) {
303             osi_Free((char *)gidset, NGROUPS * sizeof(int));
304             return EINVAL;
305         }
306         for (j = ngroups - 1; j >= 0; j--) {
307             gidset[j + 2] = gidset[j];
308         }
309         ngroups += 2;
310     }
311     *newpag = (pagvalue == -1 ? genpag() : pagvalue);
312     afs_get_groups_from_pag(*newpag, &gidset[0], &gidset[1]);
313     code = afs_setgroups(cr, ngroups, gidset, change_parent);
314
315     /* If change_parent is set, then we should set the pag in the parent as
316      * well.
317      */
318     if (change_parent && !code) {
319         code = set_pag_in_parent(*newpag, gidset[0], gidset[1]);
320     }
321
322     osi_Free((char *)gidset, NGROUPS * sizeof(int));
323     return code;
324 }
325 #endif
326
327
328 int
329 setpag(cred_t **cr, afs_uint32 pagvalue, afs_uint32 *newpag,
330        int change_parent)
331 {
332     int code;
333
334     AFS_STATCNT(setpag);
335
336     code = __setpag(cr, pagvalue, newpag, change_parent);
337
338 #ifdef LINUX_KEYRING_SUPPORT
339     if (code == 0 && (*cr)->cr_rgid != NFSXLATOR_CRED) {
340         (void) install_session_keyring(current, NULL);
341
342         if (current_session_keyring()) {
343             struct key *key;
344             key_perm_t perm;
345
346             perm = KEY_POS_VIEW | KEY_POS_SEARCH;
347             perm |= KEY_USR_VIEW | KEY_USR_SEARCH;
348
349 #ifdef KEY_ALLOC_NEEDS_STRUCT_TASK
350             key = key_alloc(&key_type_afs_pag, "_pag", 0, 0, current, perm, 1);
351 #else
352             key = key_alloc(&key_type_afs_pag, "_pag", 0, 0, perm, 1);
353 #endif
354
355             if (!IS_ERR(key)) {
356                 key_instantiate_and_link(key, (void *) newpag, sizeof(afs_uint32),
357                                          current_session_keyring(), NULL);
358                 key_put(key);
359             }
360         }
361     }
362 #endif /* LINUX_KEYRING_SUPPORT */
363
364     return code;
365 }
366
367
368 /* Intercept the standard system call. */
369 extern asmlinkage long (*sys_setgroupsp) (int gidsetsize, gid_t * grouplist);
370 asmlinkage long
371 afs_xsetgroups(int gidsetsize, gid_t * grouplist)
372 {
373     long code;
374     cred_t *cr = crref();
375     afs_uint32 junk;
376     int old_pag;
377
378     lock_kernel();
379     old_pag = PagInCred(cr);
380     crfree(cr);
381     unlock_kernel();
382
383     code = (*sys_setgroupsp) (gidsetsize, grouplist);
384     if (code) {
385         return code;
386     }
387
388     lock_kernel();
389     cr = crref();
390     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
391         /* re-install old pag if there's room. */
392         code = __setpag(&cr, old_pag, &junk, 0);
393     }
394     crfree(cr);
395     unlock_kernel();
396
397     /* Linux syscall ABI returns errno as negative */
398     return (-code);
399 }
400
401 #if defined(AFS_LINUX24_ENV)
402 /* Intercept the standard uid32 system call. */
403 extern asmlinkage long (*sys_setgroups32p) (int gidsetsize, gid_t * grouplist);
404 asmlinkage long
405 afs_xsetgroups32(int gidsetsize, gid_t * grouplist)
406 {
407     long code;
408     cred_t *cr = crref();
409     afs_uint32 junk;
410     int old_pag;
411
412     lock_kernel();
413     old_pag = PagInCred(cr);
414     crfree(cr);
415     unlock_kernel();
416
417     code = (*sys_setgroups32p) (gidsetsize, grouplist);
418
419     if (code) {
420         return code;
421     }
422
423     lock_kernel();
424     cr = crref();
425     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
426         /* re-install old pag if there's room. */
427         code = __setpag(&cr, old_pag, &junk, 0);
428     }
429     crfree(cr);
430     unlock_kernel();
431
432     /* Linux syscall ABI returns errno as negative */
433     return (-code);
434 }
435 #endif
436
437 #if defined(AFS_PPC64_LINUX20_ENV)
438 /* Intercept the uid16 system call as used by 32bit programs. */
439 extern long (*sys32_setgroupsp)(int gidsetsize, gid_t *grouplist);
440 asmlinkage long afs32_xsetgroups(int gidsetsize, gid_t *grouplist)
441 {
442     long code;
443     cred_t *cr = crref();
444     afs_uint32 junk;
445     int old_pag;
446     
447     lock_kernel();
448     old_pag = PagInCred(cr);
449     crfree(cr);
450     unlock_kernel();
451     
452     code = (*sys32_setgroupsp)(gidsetsize, grouplist);
453     if (code) {
454         return code;
455     }
456     
457     lock_kernel();
458     cr = crref();
459     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
460         /* re-install old pag if there's room. */
461         code = __setpag(&cr, old_pag, &junk, 0);
462     }
463     crfree(cr);
464     unlock_kernel();
465     
466     /* Linux syscall ABI returns errno as negative */
467     return (-code);
468 }
469 #endif
470
471 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_AMD64_LINUX20_ENV)
472 /* Intercept the uid16 system call as used by 32bit programs. */
473 extern long (*sys32_setgroupsp) (int gidsetsize, u16 * grouplist);
474 asmlinkage long
475 afs32_xsetgroups(int gidsetsize, u16 * grouplist)
476 {
477     long code;
478     cred_t *cr = crref();
479     afs_uint32 junk;
480     int old_pag;
481     
482     lock_kernel();
483     old_pag = PagInCred(cr);
484     crfree(cr);
485     unlock_kernel();
486     
487     code = (*sys32_setgroupsp) (gidsetsize, grouplist);
488     if (code) {
489         return code;
490     }
491     
492     lock_kernel();
493     cr = crref();
494     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
495         /* re-install old pag if there's room. */
496         code = __setpag(&cr, old_pag, &junk, 0);
497     }
498     crfree(cr);
499     unlock_kernel();
500     
501     /* Linux syscall ABI returns errno as negative */
502     return (-code);
503 }
504
505 #ifdef AFS_LINUX24_ENV
506 /* Intercept the uid32 system call as used by 32bit programs. */
507 extern long (*sys32_setgroups32p) (int gidsetsize, gid_t * grouplist);
508 asmlinkage long
509 afs32_xsetgroups32(int gidsetsize, gid_t * grouplist)
510 {
511     long code;
512     cred_t *cr = crref();
513     afs_uint32 junk;
514     int old_pag;
515
516     lock_kernel();
517     old_pag = PagInCred(cr);
518     crfree(cr);
519     unlock_kernel();
520
521     code = (*sys32_setgroups32p) (gidsetsize, grouplist);
522     if (code) {
523         return code;
524     }
525
526     lock_kernel();
527     cr = crref();
528     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
529         /* re-install old pag if there's room. */
530         code = __setpag(&cr, old_pag, &junk, 0);
531     }
532     crfree(cr);
533     unlock_kernel();
534
535     /* Linux syscall ABI returns errno as negative */
536     return (-code);
537 }
538 #endif
539 #endif
540
541
542 #ifdef LINUX_KEYRING_SUPPORT
543 static void afs_pag_describe(const struct key *key, struct seq_file *m)
544 {
545     seq_puts(m, key->description);
546
547     seq_printf(m, ": %u", key->datalen);
548 }
549
550 static int afs_pag_instantiate(struct key *key, const void *data, size_t datalen)
551 {
552     int code;
553     afs_uint32 *userpag, pag = NOPAG;
554 #ifndef AFS_LINUX26_ONEGROUP_ENV
555     int g0, g1;
556 #endif
557
558     if (key->uid != 0 || key->gid != 0)
559         return -EPERM;
560
561     code = -EINVAL;
562     get_group_info(current_group_info());
563
564     if (datalen != sizeof(afs_uint32) || !data)
565         goto error;
566
567     if (current_group_info()->ngroups < NUMPAGGROUPS)
568         goto error;
569
570     /* ensure key being set matches current pag */
571 #ifdef AFS_LINUX26_ONEGROUP_ENV
572     pag = afs_get_pag_from_groups(current_group_info());
573 #else
574     g0 = GROUP_AT(current_group_info(), 0);
575     g1 = GROUP_AT(current_group_info(), 1);
576
577     pag = afs_get_pag_from_groups(g0, g1);
578 #endif
579     if (pag == NOPAG)
580         goto error;
581
582     userpag = (afs_uint32 *) data;
583     if (*userpag != pag)
584         goto error;
585
586     key->payload.value = (unsigned long) *userpag;
587     key->datalen = sizeof(afs_uint32);
588     code = 0;
589
590 error:
591     put_group_info(current_group_info());
592     return code;
593 }
594
595 static int afs_pag_match(const struct key *key, const void *description)
596 {
597         return strcmp(key->description, description) == 0;
598 }
599
600 static void afs_pag_destroy(struct key *key)
601 {
602     afs_uint32 pag = key->payload.value;
603     struct unixuser *pu;
604     int locked = ISAFS_GLOCK();
605
606     if (!locked)
607         AFS_GLOCK();
608     pu = afs_FindUser(pag, -1, READ_LOCK);
609     if (pu) {
610         pu->ct.EndTimestamp = 0;
611         pu->tokenTime = 0;
612         afs_PutUser(pu, READ_LOCK);
613     }
614     if (!locked)
615         AFS_GUNLOCK();
616 }
617
618 struct key_type key_type_afs_pag =
619 {
620     .name        = "afs_pag",
621     .describe    = afs_pag_describe,
622     .instantiate = afs_pag_instantiate,
623     .match       = afs_pag_match,
624     .destroy     = afs_pag_destroy,
625 };
626
627 #ifdef EXPORTED_TASKLIST_LOCK
628 extern rwlock_t tasklist_lock __attribute__((weak));
629 #endif
630
631 void osi_keyring_init(void)
632 {
633     struct task_struct *p;
634
635     /* If we can't lock the tasklist, either with its explicit lock,
636      * or by using the RCU lock, then we can't safely work out the 
637      * type of a keyring. So, we have to rely on the weak reference. 
638      * If that's not available, then keyring based PAGs won't work.
639      */
640     
641 #if defined(EXPORTED_TASKLIST_LOCK) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16) && defined(EXPORTED_RCU_READ_LOCK))
642     if (__key_type_keyring == NULL) {
643 # ifdef EXPORTED_TASKLIST_LOCK
644         if (&tasklist_lock)
645             read_lock(&tasklist_lock);
646 # endif
647 # if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16) && defined(EXPORTED_RCU_READ_LOCK))
648 #  ifdef EXPORTED_TASKLIST_LOCK
649         else
650 #  endif
651             rcu_read_lock();
652 # endif
653 #if defined(EXPORTED_FIND_TASK_BY_PID)
654         p = find_task_by_pid(1);
655 #else
656         p = find_task_by_vpid(1);
657 #endif
658         if (p && task_user(p)->session_keyring)
659             __key_type_keyring = task_user(p)->session_keyring->type;
660 # ifdef EXPORTED_TASKLIST_LOCK
661         if (&tasklist_lock)
662             read_unlock(&tasklist_lock);
663 # endif
664 # if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16) && defined(EXPORTED_RCU_READ_LOCK))
665 #  ifdef EXPORTED_TASKLIST_LOCK
666         else
667 #  endif
668             rcu_read_unlock();
669 # endif
670     }
671 #endif
672
673     register_key_type(&key_type_afs_pag);
674 }
675
676 void osi_keyring_shutdown(void)
677 {
678     unregister_key_type(&key_type_afs_pag);
679 }
680
681 #else
682 void osi_keyring_init(void)
683 {
684         return;
685 }
686
687 void osi_keyring_shutdown(void)
688 {
689         return;
690 }
691 #endif