amd64-hook-ia32-table-20030521
[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
19 RCSID("$Header$");
20
21 #include "afs/sysincludes.h"
22 #include "afsincludes.h"
23 #include "afs/afs_stats.h"  /* statistics */
24 #ifdef AFS_LINUX22_ENV
25 #include "h/smp_lock.h"
26 #endif
27
28 static int afs_getgroups(cred_t *cr, gid_t *groups);
29 static int afs_setgroups(cred_t **cr, int ngroups, gid_t *gidset, int change_parent);
30
31 /* Only propogate the PAG to the parent process. Unix's propogate to 
32  * all processes sharing the cred.
33  */
34 int set_pag_in_parent(int pag, int g0, int g1)
35 {
36 #ifdef STRUCT_TASK_STRUCT_HAS_PARENT
37     gid_t *gp = current->parent->groups;
38 #else
39     gid_t *gp = current->p_pptr->groups;
40 #endif
41     int ngroups;
42     int i;
43
44     
45 #ifdef STRUCT_TASK_STRUCT_HAS_PARENT
46     ngroups = current->parent->ngroups;
47 #else
48     ngroups = current->p_pptr->ngroups;
49 #endif
50
51     if ((ngroups < 2) || (afs_get_pag_from_groups(gp[0], gp[1]) == NOPAG)) {
52         /* We will have to shift grouplist to make room for pag */
53         if (ngroups + 2 > NGROUPS) {
54             return EINVAL;
55         }
56         for (i = ngroups-1; i >= 0; i--) {
57             gp[i+2] = gp[i];
58         }
59         ngroups += 2;
60     }
61     gp[0] = g0;
62     gp[1] = g1;
63     if (ngroups < NGROUPS)
64         gp[ngroups] = NOGROUP;
65
66 #ifdef STRUCT_TASK_STRUCT_HAS_PARENT
67     current->parent->ngroups = ngroups;
68 #else
69     current->p_pptr->ngroups = ngroups;
70 #endif
71     return 0;
72 }
73
74 int setpag(cred_t **cr, afs_uint32 pagvalue, afs_uint32 *newpag, int change_parent)
75 {
76     gid_t *gidset;
77     afs_int32 ngroups, code = 0;
78     int j;
79
80     AFS_STATCNT(setpag);
81
82     gidset = (gid_t *) osi_Alloc(NGROUPS*sizeof(gidset[0]));
83     ngroups = afs_getgroups(*cr, gidset);
84
85     if (afs_get_pag_from_groups(gidset[0], gidset[1]) == NOPAG) {
86         /* We will have to shift grouplist to make room for pag */
87         if (ngroups + 2 > NGROUPS) {
88             osi_Free((char *)gidset, NGROUPS*sizeof(int));
89             return EINVAL;
90         }
91         for (j = ngroups - 1; j >= 0; j--) {
92             gidset[j+2] = gidset[j];
93         }
94         ngroups += 2;
95     }
96     *newpag = (pagvalue == -1 ? genpag(): pagvalue);
97     afs_get_groups_from_pag(*newpag, &gidset[0], &gidset[1]);
98     code = afs_setgroups(cr, ngroups, gidset, change_parent);
99
100     /* If change_parent is set, then we should set the pag in the parent as
101      * well.
102      */
103     if (change_parent && !code) {
104         code = set_pag_in_parent(*newpag, gidset[0], gidset[1]);
105     }
106
107     osi_Free((char *)gidset, NGROUPS*sizeof(int));
108     return code;
109 }
110
111
112 /* Intercept the standard system call. */
113 extern long (*sys_setgroupsp)(int gidsetsize, gid_t *grouplist);
114 asmlinkage long afs_xsetgroups(int gidsetsize, gid_t *grouplist)
115 {
116     long code;
117     cred_t *cr = crref();
118     afs_uint32 junk;
119     int old_pag;
120
121     lock_kernel();
122     old_pag = PagInCred(cr);
123     crfree(cr);
124     unlock_kernel();
125
126     code = (*sys_setgroupsp)(gidsetsize, grouplist);
127     if (code) {
128         return code;
129     }
130
131     lock_kernel();
132     cr = crref();
133     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
134         /* re-install old pag if there's room. */
135         code = setpag(&cr, old_pag, &junk, 0);
136     }
137     crfree(cr);
138     unlock_kernel();
139
140     /* Linux syscall ABI returns errno as negative */
141     return (- code);
142 }
143
144 #if defined(AFS_LINUX24_ENV)
145 /* Intercept the standard uid32 system call. */
146 extern long (*sys_setgroups32p)(int gidsetsize, gid_t *grouplist);
147 asmlinkage long afs_xsetgroups32(int gidsetsize, gid_t *grouplist)
148 {
149     long code;
150     cred_t *cr = crref();
151     afs_uint32 junk;
152     int old_pag;
153     
154     lock_kernel();
155     old_pag = PagInCred(cr);
156     crfree(cr);
157     unlock_kernel();
158
159     code = (*sys_setgroups32p)(gidsetsize, grouplist);
160
161     if (code) {
162         return code;
163     }
164
165     lock_kernel();
166     cr = crref();
167     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
168         /* re-install old pag if there's room. */
169         code = setpag(&cr, old_pag, &junk, 0);
170     }
171     crfree(cr);
172     unlock_kernel();
173
174     /* Linux syscall ABI returns errno as negative */
175     return (- code);
176 }
177 #endif
178
179 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_AMD64_LINUX20_ENV)
180 /* Intercept the uid16 system call as used by 32bit programs. */
181 extern long (*sys32_setgroupsp)(int gidsetsize, old_gid_t *grouplist);
182 asmlinkage long afs32_xsetgroups(int gidsetsize, old_gid_t *grouplist)
183 {
184     long code;
185     cred_t *cr = crref();
186     afs_uint32 junk;
187     int old_pag;
188
189     lock_kernel();
190     old_pag = PagInCred(cr);
191     crfree(cr);
192     unlock_kernel();
193
194     code = (*sys32_setgroupsp)(gidsetsize, grouplist);
195     if (code) {
196         return code;
197     }
198
199     lock_kernel();
200     cr = crref();
201     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
202         /* re-install old pag if there's room. */
203         code = setpag(&cr, old_pag, &junk, 0);
204     }
205     crfree(cr);
206     unlock_kernel();
207
208     /* Linux syscall ABI returns errno as negative */
209     return (- code);
210 }
211 #ifdef AFS_LINUX24_ENV
212 /* Intercept the uid32 system call as used by 32bit programs. */
213 extern long (*sys32_setgroups32p)(int gidsetsize, gid_t *grouplist);
214 asmlinkage long afs32_xsetgroups32(int gidsetsize, gid_t *grouplist)
215 {
216     long code;
217     cred_t *cr = crref();
218     afs_uint32 junk;
219     int old_pag;
220
221     lock_kernel();
222     old_pag = PagInCred(cr);
223     crfree(cr);
224     unlock_kernel();
225
226     code = (*sys32_setgroups32p)(gidsetsize, grouplist);
227     if (code) {
228         return code;
229     }
230
231     lock_kernel();
232     cr = crref();
233     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
234         /* re-install old pag if there's room. */
235         code = setpag(&cr, old_pag, &junk, 0);
236     }
237     crfree(cr);
238     unlock_kernel();
239
240     /* Linux syscall ABI returns errno as negative */
241     return (- code);
242 }
243 #endif
244 #endif
245
246 static int afs_setgroups(cred_t **cr, int ngroups, gid_t *gidset, int change_parent)
247 {
248     int ngrps;
249     int i;
250     gid_t *gp;
251
252     AFS_STATCNT(afs_setgroups);
253
254     if (ngroups > NGROUPS)
255         return EINVAL;
256
257     gp = (*cr)->cr_groups;
258     if (ngroups < NGROUPS)
259         gp[ngroups] = (gid_t)NOGROUP;
260
261     for (i = ngroups; i > 0; i--) {
262         *gp++ = *gidset++;
263     }
264
265     (*cr)->cr_ngroups = ngroups;
266     crset(*cr);
267     return (0);
268 }
269
270 /* Returns number of groups. And we trust groups to be large enough to
271  * hold all the groups.
272  */
273 static int afs_getgroups(cred_t *cr, gid_t *groups)
274 {
275     int i;
276     gid_t *gp = cr->cr_groups;
277     int n = cr->cr_ngroups;
278     AFS_STATCNT(afs_getgroups);
279
280     for (i = 0; (i < n) && (*gp != (gid_t)NOGROUP); i++) {
281         *groups++ = *gp++;
282     }
283     return i;
284 }
285