f5dcf56a0e28f44a39e1fc046b60abb1ef0253f8
[openafs.git] / src / afs / afs_syscall.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 #include <afsconfig.h>
11 #include "afs/param.h"
12
13 #ifdef IGNORE_SOME_GCC_WARNINGS
14 # pragma GCC diagnostic warning "-Wold-style-definition"
15 # pragma GCC diagnostic warning "-Wstrict-prototypes"
16 #endif
17
18 #include "afs/sysincludes.h"    /* Standard vendor system headers */
19 #include "afsincludes.h"        /* Afs-based standard headers */
20 #include "afs/afs_stats.h"
21 #include "rx/rx_globals.h"
22 #if !defined(UKERNEL) && !defined(AFS_LINUX20_ENV)
23 #include "net/if.h"
24 #ifdef AFS_SGI62_ENV
25 #include "h/hashing.h"
26 #endif
27 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN_ENV)
28 #include "netinet/in_var.h"
29 #endif
30 #endif /* !defined(UKERNEL) */
31 #ifdef AFS_LINUX22_ENV
32 #include "h/smp_lock.h"
33 #endif
34
35 #if (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)) || defined(AFS_HPUX_64BIT_ENV) || defined(AFS_SUN57_64BIT_ENV) || (defined(AFS_SGI_ENV) && (_MIPS_SZLONG==64)) || defined(NEED_IOCTL32)
36 static void
37 afs_ioctl32_to_afs_ioctl(const struct afs_ioctl32 *src, struct afs_ioctl *dst)
38 {
39 #ifdef AFS_DARWIN100_ENV
40     dst->in = CAST_USER_ADDR_T(src->in);
41     dst->out = CAST_USER_ADDR_T(src->out);
42 #else
43     dst->in = (char *)(unsigned long)src->in;
44     dst->out = (char *)(unsigned long)src->out;
45 #endif
46     dst->in_size = src->in_size;
47     dst->out_size = src->out_size;
48 }
49 #endif
50
51 /*
52  * If you need to change copyin_afs_ioctl(), you may also need to change
53  * copyin_iparam().
54  */
55
56 int
57 #ifdef AFS_DARWIN100_ENV
58 copyin_afs_ioctl(user_addr_t cmarg, struct afs_ioctl *dst)
59 #else
60 copyin_afs_ioctl(caddr_t cmarg, struct afs_ioctl *dst)
61 #endif
62 {
63     int code;
64 #if defined(AFS_DARWIN100_ENV)
65     struct afs_ioctl32 dst32;
66     
67     if (!proc_is64bit(current_proc())) {
68         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
69         if (!code)
70             afs_ioctl32_to_afs_ioctl(&dst32, dst);
71         return code;
72     }
73 #endif
74 #if defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)
75     struct afs_ioctl32 dst32;
76
77     if (!(IS64U)) {
78         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
79         if (!code)
80             afs_ioctl32_to_afs_ioctl(&dst32, dst);
81         return code;
82     }
83 #endif /* defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL) */
84
85
86 #if defined(AFS_HPUX_64BIT_ENV)
87     struct afs_ioctl32 dst32;
88
89     if (is_32bit(u.u_procp)) {  /* is_32bit() in proc_iface.h */
90         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
91         if (!code)
92             afs_ioctl32_to_afs_ioctl(&dst32, dst);
93         return code;
94     }
95 #endif /* defined(AFS_HPUX_64BIT_ENV) */
96
97 #if defined(AFS_SUN57_64BIT_ENV)
98     struct afs_ioctl32 dst32;
99
100     if (get_udatamodel() == DATAMODEL_ILP32) {
101         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
102         if (!code)
103             afs_ioctl32_to_afs_ioctl(&dst32, dst);
104         return code;
105     }
106 #endif /* defined(AFS_SUN57_64BIT_ENV) */
107
108 #if defined(AFS_SGI_ENV) && (_MIPS_SZLONG==64)
109     struct afs_ioctl32 dst32;
110
111     if (!ABI_IS_64BIT(get_current_abi())) {
112         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
113         if (!code)
114             afs_ioctl32_to_afs_ioctl(&dst32, dst);
115         return code;
116     }
117 #endif /* defined(AFS_SGI_ENV) && (_MIPS_SZLONG==64) */
118
119 #if defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_ALPHA_LINUX20_ENV) && !defined(AFS_IA64_LINUX20_ENV)
120     struct afs_ioctl32 dst32;
121
122 #ifdef AFS_SPARC64_LINUX26_ENV
123     if (test_thread_flag(TIF_32BIT))
124 #elif defined(AFS_SPARC64_LINUX24_ENV)
125     if (current->thread.flags & SPARC_FLAG_32BIT)
126 #elif defined(AFS_SPARC64_LINUX20_ENV)
127     if (current->tss.flags & SPARC_FLAG_32BIT)
128
129 #elif defined(AFS_AMD64_LINUX26_ENV)
130     if (test_thread_flag(TIF_IA32))
131 #elif defined(AFS_AMD64_LINUX20_ENV)
132     if (current->thread.flags & THREAD_IA32)
133
134 #elif defined(AFS_PPC64_LINUX26_ENV)
135 #if defined(STRUCT_TASK_STRUCT_HAS_THREAD_INFO)
136     if (current->thread_info->flags & _TIF_32BIT) 
137 #else
138     if (task_thread_info(current)->flags & _TIF_32BIT) 
139 #endif      
140 #elif defined(AFS_PPC64_LINUX20_ENV)
141     if (current->thread.flags & PPC_FLAG_32BIT)
142
143 #elif defined(AFS_S390X_LINUX26_ENV)
144     if (test_thread_flag(TIF_31BIT))
145 #elif defined(AFS_S390X_LINUX20_ENV)
146     if (current->thread.flags & S390_FLAG_31BIT)
147
148 #else
149 #error pioctl32 not done for this linux
150 #endif
151     {
152         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
153         if (!code)
154             afs_ioctl32_to_afs_ioctl(&dst32, dst);
155         return code;
156     }
157 #endif /* defined(AFS_LINUX_64BIT_KERNEL) */
158
159     AFS_COPYIN(cmarg, (caddr_t) dst, sizeof *dst, code);
160     return code;
161 }
162
163
164 #ifdef AFS_AIX32_ENV
165
166 #include "sys/lockl.h"
167
168 /*
169  * syscall -    this is the VRMIX system call entry point.
170  *
171  * NOTE:
172  *      THIS SHOULD BE CHANGED TO afs_syscall(), but requires
173  *      all the user-level calls to `syscall' to change.
174  */
175 syscall(syscall, p1, p2, p3, p4, p5, p6)
176 {
177     register rval1 = 0, code;
178     register monster;
179     int retval = 0;
180 #ifndef AFS_AIX41_ENV
181     extern lock_t kernel_lock;
182     monster = lockl(&kernel_lock, LOCK_SHORT);
183 #endif /* !AFS_AIX41_ENV */
184
185     AFS_STATCNT(syscall);
186     setuerror(0);
187     switch (syscall) {
188     case AFSCALL_CALL:
189         rval1 = afs_syscall_call(p1, p2, p3, p4, p5, p6);
190         break;
191
192     case AFSCALL_SETPAG:
193         AFS_GLOCK();
194         rval1 = afs_setpag();
195         AFS_GUNLOCK();
196         break;
197
198     case AFSCALL_PIOCTL:
199         AFS_GLOCK();
200         rval1 = afs_syscall_pioctl(p1, p2, p3, p4);
201         AFS_GUNLOCK();
202         break;
203
204     case AFSCALL_ICREATE:
205         rval1 = afs_syscall_icreate(p1, p2, p3, p4, p5, p6);
206         break;
207
208     case AFSCALL_IOPEN:
209         rval1 = afs_syscall_iopen(p1, p2, p3);
210         break;
211
212     case AFSCALL_IDEC:
213         rval1 = afs_syscall_iincdec(p1, p2, p3, -1);
214         break;
215
216     case AFSCALL_IINC:
217         rval1 = afs_syscall_iincdec(p1, p2, p3, 1);
218         break;
219
220     case AFSCALL_ICL:
221         AFS_GLOCK();
222         code = Afscall_icl(p1, p2, p3, p4, p5, &retval);
223         AFS_GUNLOCK();
224         if (!code)
225             rval1 = retval;
226         if (!rval1)
227             rval1 = code;
228         break;
229
230     default:
231         rval1 = EINVAL;
232         setuerror(EINVAL);
233         break;
234     }
235
236   out:
237 #ifndef AFS_AIX41_ENV
238     if (monster != LOCK_NEST)
239         unlockl(&kernel_lock);
240 #endif /* !AFS_AIX41_ENV */
241     return getuerror()? -1 : rval1;
242 }
243
244 /*
245  * lsetpag -    interface to afs_setpag().
246  */
247 int
248 lsetpag(void)
249 {
250
251     AFS_STATCNT(lsetpag);
252     return syscall(AFSCALL_SETPAG, 0, 0, 0, 0, 0);
253 }
254
255 /*
256  * lpioctl -    interface to pioctl()
257  */
258 int
259 lpioctl(char *path, int cmd, void *cmarg, int follow)
260 {
261
262     AFS_STATCNT(lpioctl);
263     return syscall(AFSCALL_PIOCTL, path, cmd, cmarg, follow);
264 }
265
266 #else /* !AFS_AIX32_ENV       */
267
268 #if defined(AFS_SGI_ENV)
269 struct afsargs {
270     sysarg_t syscall;
271     sysarg_t parm1;
272     sysarg_t parm2;
273     sysarg_t parm3;
274     sysarg_t parm4;
275     sysarg_t parm5;
276 };
277
278
279 int
280 Afs_syscall(struct afsargs *uap, rval_t * rvp)
281 {
282     int error;
283     long retval;
284
285     AFS_STATCNT(afs_syscall);
286     switch (uap->syscall) {
287     case AFSCALL_ICL:
288         retval = 0;
289         AFS_GLOCK();
290         error =
291             Afscall_icl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
292                         uap->parm5, &retval);
293         AFS_GUNLOCK();
294         rvp->r_val1 = retval;
295         break;
296 #ifdef AFS_SGI_XFS_IOPS_ENV
297     case AFSCALL_IDEC64:
298         error =
299             afs_syscall_idec64(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
300                                uap->parm5);
301         break;
302     case AFSCALL_IINC64:
303         error =
304             afs_syscall_iinc64(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
305                                uap->parm5);
306         break;
307     case AFSCALL_ILISTINODE64:
308         error =
309             afs_syscall_ilistinode64(uap->parm1, uap->parm2, uap->parm3,
310                                      uap->parm4, uap->parm5);
311         break;
312     case AFSCALL_ICREATENAME64:
313         error =
314             afs_syscall_icreatename64(uap->parm1, uap->parm2, uap->parm3,
315                                       uap->parm4, uap->parm5);
316         break;
317 #endif
318 #ifdef AFS_SGI_VNODE_GLUE
319     case AFSCALL_INIT_KERNEL_CONFIG:
320         error = afs_init_kernel_config(uap->parm1);
321         break;
322 #endif
323     default:
324         error =
325             afs_syscall_call(uap->syscall, uap->parm1, uap->parm2, uap->parm3,
326                              uap->parm4, uap->parm5);
327     }
328     return error;
329 }
330
331 #else /* AFS_SGI_ENV */
332
333 struct iparam {
334     iparmtype param1;
335     iparmtype param2;
336     iparmtype param3;
337     iparmtype param4;
338 };
339
340 struct iparam32 {
341     int param1;
342     int param2;
343     int param3;
344     int param4;
345 };
346
347
348 #if defined(AFS_HPUX_64BIT_ENV) || defined(AFS_SUN57_64BIT_ENV) || (defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_ALPHA_LINUX20_ENV) && !defined(AFS_IA64_LINUX20_ENV)) || defined(NEED_IOCTL32)
349 #if SIZEOF_VOID_P == SIZEOF_UNSIGNED_INT
350 # define uintptrsz unsigned int
351 #elif SIZEOF_VOID_P == SIZEOF_UNSIGNED_LONG
352 # define uintptrsz unsigned long
353 #elif SIZEOF_VOID_P == SIZEOF_UNSIGNED_LONG_LONG
354 # define uintptrsz unsigned long long
355 #else
356 # error "Unable to determine casting for pointers"
357 #endif
358 static void
359 iparam32_to_iparam(const struct iparam32 *src, struct iparam *dst)
360 {
361     dst->param1 = (iparmtype)(uintptrsz)src->param1;
362     dst->param2 = (iparmtype)(uintptrsz)src->param2;
363     dst->param3 = (iparmtype)(uintptrsz)src->param3;
364     dst->param4 = (iparmtype)(uintptrsz)src->param4;
365 }
366 #endif
367
368 /*
369  * If you need to change copyin_iparam(), you may also need to change
370  * copyin_afs_ioctl().
371  *
372  * This function is needed only for icreate, meaning, only on platforms
373  * providing the inode fileserver.
374  */
375
376 static int
377 copyin_iparam(caddr_t cmarg, struct iparam *dst)
378 {
379     int code;
380
381 #if defined(AFS_HPUX_64BIT_ENV)
382     struct iparam32 dst32;
383
384     if (is_32bit(u.u_procp)) {  /* is_32bit() in proc_iface.h */
385         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
386         if (!code)
387             iparam32_to_iparam(&dst32, dst);
388         return code;
389     }
390 #endif /* AFS_HPUX_64BIT_ENV */
391
392 #if defined(AFS_SUN57_64BIT_ENV)
393     struct iparam32 dst32;
394
395     if (get_udatamodel() == DATAMODEL_ILP32) {
396         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
397         if (!code)
398             iparam32_to_iparam(&dst32, dst);
399         return code;
400     }
401 #endif /* AFS_SUN57_64BIT_ENV */
402
403 #if defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_ALPHA_LINUX20_ENV) && !defined(AFS_IA64_LINUX20_ENV)
404     struct iparam32 dst32;
405
406 #ifdef AFS_SPARC64_LINUX26_ENV
407     if (test_thread_flag(TIF_32BIT))
408 #elif defined(AFS_SPARC64_LINUX24_ENV)
409     if (current->thread.flags & SPARC_FLAG_32BIT)
410 #elif defined(AFS_SPARC64_LINUX20_ENV)
411     if (current->tss.flags & SPARC_FLAG_32BIT)
412
413 #elif defined(AFS_AMD64_LINUX26_ENV)
414     if (test_thread_flag(TIF_IA32))
415 #elif defined(AFS_AMD64_LINUX20_ENV)
416     if (current->thread.flags & THREAD_IA32)
417
418 #elif defined(AFS_PPC64_LINUX26_ENV)
419 #if defined(STRUCT_TASK_STRUCT_HAS_THREAD_INFO)
420     if (current->thread_info->flags & _TIF_32BIT) 
421 #else
422     if (task_thread_info(current)->flags & _TIF_32BIT) 
423 #endif      
424 #elif defined(AFS_PPC64_LINUX20_ENV)
425     if (current->thread.flags & PPC_FLAG_32BIT) 
426
427 #elif defined(AFS_S390X_LINUX26_ENV)
428     if (test_thread_flag(TIF_31BIT))
429 #elif defined(AFS_S390X_LINUX20_ENV)
430     if (current->thread.flags & S390_FLAG_31BIT) 
431
432 #else
433 #error iparam32 not done for this linux platform
434 #endif
435     {
436         AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
437         if (!code)
438             iparam32_to_iparam(&dst32, dst);
439         return code;
440     }
441 #endif /* AFS_LINUX_64BIT_KERNEL */
442
443     AFS_COPYIN(cmarg, (caddr_t) dst, sizeof *dst, code);
444     return code;
445 }
446
447 /* Main entry of all afs system calls */
448 #ifdef  AFS_SUN5_ENV
449 extern int afs_sinited;
450
451 /** The 32 bit OS expects the members of this structure to be 32 bit
452  * quantities and the 64 bit OS expects them as 64 bit quanties. Hence
453  * to accomodate both, *long* is used instead of afs_int32
454  */
455
456 # ifdef AFS_SUN57_ENV
457 struct afssysa {
458     long syscall;
459     long parm1;
460     long parm2;
461     long parm3;
462     long parm4;
463     long parm5;
464     long parm6;
465 };
466 # else
467 struct afssysa {
468     afs_int32 syscall;
469     afs_int32 parm1;
470     afs_int32 parm2;
471     afs_int32 parm3;
472     afs_int32 parm4;
473     afs_int32 parm5;
474     afs_int32 parm6;
475 };
476 # endif
477
478 Afs_syscall(register struct afssysa *uap, rval_t * rvp)
479 {
480     int *retval = &rvp->r_val1;
481 #elif defined(AFS_DARWIN100_ENV)
482 struct afssysa {
483     afs_int32 syscall;
484     afs_int32 parm1;
485     afs_int32 parm2;
486     afs_int32 parm3;
487     afs_int32 parm4;
488     afs_int32 parm5;
489     afs_int32 parm6;
490 };
491 struct afssysa64 {
492     afs_int64 parm1;
493     afs_int64 parm2;
494     afs_int64 parm3;
495     afs_int64 parm4;
496     afs_int64 parm5;
497     afs_int64 parm6;
498     afs_int32 syscall;
499 };
500 int
501 afs3_syscall(afs_proc_t *p, void *args, unsigned int *retval)
502 {
503     struct afssysa64 *uap64 = NULL;
504     struct afssysa *uap = NULL;
505 #elif defined(AFS_FBSD_ENV)
506 int
507 afs3_syscall(struct thread *p, void *args)
508 {
509     register struct a {
510         long syscall;
511         long parm1;
512         long parm2;
513         long parm3;
514         long parm4;
515         long parm5;
516         long parm6;
517     } *uap = (struct a *)args;
518     long *retval;
519 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
520 int
521 afs3_syscall(afs_proc_t *p, void *args, long *retval)
522 {
523     register struct a {
524         long syscall;
525         long parm1;
526         long parm2;
527         long parm3;
528         long parm4;
529         long parm5;
530         long parm6;
531     } *uap = (struct a *)args;
532 #elif defined(AFS_LINUX20_ENV)
533 struct afssysargs {
534     long syscall;
535     long parm1;
536     long parm2;
537     long parm3;
538     long parm4;
539     long parm5;
540     long parm6;                 /* not actually used - should be removed */
541 };
542 /* Linux system calls only set up for 5 arguments. */
543 asmlinkage long
544 afs_syscall(long syscall, long parm1, long parm2, long parm3, long parm4)
545 {
546     struct afssysargs args, *uap = &args;
547     long linux_ret = 0;
548     long *retval = &linux_ret;
549     long eparm[4];              /* matches AFSCALL_ICL in fstrace.c */
550 # ifdef AFS_SPARC64_LINUX24_ENV
551     afs_int32 eparm32[4];
552 # endif
553     /* eparm is also used by AFSCALL_CALL in afsd.c */
554 #else
555 # if defined(UKERNEL)
556 int
557 Afs_syscall()
558 {
559     register struct a {
560         long syscall;
561         long parm1;
562         long parm2;
563         long parm3;
564         long parm4;
565         long parm5;
566         long parm6;
567     } *uap = (struct a *)get_user_struct()->u_ap;
568 # else /* UKERNEL */
569 int
570 Afs_syscall()
571 {
572     register struct a {
573         long syscall;
574         long parm1;
575         long parm2;
576         long parm3;
577         long parm4;
578         long parm5;
579         long parm6;
580     } *uap = (struct a *)u.u_ap;
581 # endif /* UKERNEL */
582 # if defined(AFS_HPUX_ENV)
583     long *retval = &u.u_rval1;
584 # elif defined(UKERNEL)
585     int *retval = &(get_user_struct()->u_rval1);
586 # else
587     int *retval = &u.u_rval1;
588 # endif
589 #endif
590     register int code = 0;
591
592     AFS_STATCNT(afs_syscall);
593 #ifdef        AFS_SUN5_ENV
594     rvp->r_vals = 0;
595     if (!afs_sinited) {
596         return (ENODEV);
597     }
598 #endif
599 #ifdef AFS_LINUX20_ENV
600     lock_kernel();
601     /* setup uap for use below - pull out the magic decoder ring to know
602      * which syscalls have folded argument lists.
603      */
604     uap->syscall = syscall;
605     uap->parm1 = parm1;
606     uap->parm2 = parm2;
607     uap->parm3 = parm3;
608     if (syscall == AFSCALL_ICL || syscall == AFSCALL_CALL) {
609 #ifdef AFS_SPARC64_LINUX24_ENV
610 /* from arch/sparc64/kernel/sys_sparc32.c */
611 #define AA(__x)                                \
612 ({     unsigned long __ret;            \
613        __asm__ ("srl   %0, 0, %0"      \
614                 : "=r" (__ret)         \
615                 : "0" (__x));          \
616        __ret;                          \
617 })
618
619
620 #ifdef AFS_SPARC64_LINUX26_ENV
621         if (test_thread_flag(TIF_32BIT))
622 #else
623         if (current->thread.flags & SPARC_FLAG_32BIT)
624 #endif
625         {
626             AFS_COPYIN((char *)parm4, (char *)eparm32, sizeof(eparm32), code);
627             eparm[0] = AA(eparm32[0]);
628             eparm[1] = AA(eparm32[1]);
629             eparm[2] = AA(eparm32[2]);
630 #undef AA
631         } else
632 #endif
633             AFS_COPYIN((char *)parm4, (char *)eparm, sizeof(eparm), code);
634         uap->parm4 = eparm[0];
635         uap->parm5 = eparm[1];
636         uap->parm6 = eparm[2];
637     } else {
638         uap->parm4 = parm4;
639         uap->parm5 = 0;
640         uap->parm6 = 0;
641     }
642 #endif
643 #if defined(AFS_DARWIN80_ENV)
644     get_vfs_context();
645     osi_Assert(*retval == 0);
646 #ifdef AFS_DARWIN100_ENV
647     if (proc_is64bit(p)) {
648         uap64 = (struct afssysa64 *)args;
649         if (uap64->syscall == AFSCALL_CALL) {
650             code =
651                 afs_syscall64_call(uap64->parm1, uap64->parm2, uap64->parm3,
652                                    uap64->parm4, uap64->parm5, uap64->parm6);
653             /* pass back the code as syscall retval */
654             if (code < 0) {
655                 *retval = code;
656                 code = 0;
657             }
658         } else if (uap64->syscall == AFSCALL_SETPAG) {
659             AFS_GLOCK();
660             code = afs_setpag(p, args, retval);
661             AFS_GUNLOCK();
662         } else if (uap64->syscall == AFSCALL_PIOCTL) {
663             AFS_GLOCK();
664             code =
665                 afs_syscall64_pioctl(uap64->parm1, (unsigned int)uap64->parm2,
666                                      uap64->parm3, (int)uap64->parm4,
667                                      kauth_cred_get());
668             AFS_GUNLOCK();
669         } else if (uap64->syscall == AFSCALL_ICL) {
670             AFS_GLOCK();
671             code =
672                 Afscall64_icl(uap64->parm1, uap64->parm2, uap64->parm3,
673                             uap64->parm4, uap64->parm5, retval);
674             AFS_GUNLOCK();
675         } else
676             code = EINVAL;
677         if (uap64->syscall != AFSCALL_CALL)
678             put_vfs_context();
679     } else { /* and the default case for 32 bit procs */
680 #endif
681         uap = (struct afssysa *)args;
682 #endif
683 #if defined(AFS_HPUX_ENV)
684     /*
685      * There used to be code here (duplicated from osi_Init()) for
686      * initializing the semaphore used by AFS_GLOCK().  Was the
687      * duplication to handle the case of a dynamically loaded kernel
688      * module?
689      */
690         osi_InitGlock();
691 #endif
692         if (uap->syscall == AFSCALL_CALL) {
693             code =
694                 afs_syscall_call(uap->parm1, uap->parm2, uap->parm3,
695                                  uap->parm4, uap->parm5, uap->parm6);
696 #ifdef AFS_DARWIN_ENV
697             /* pass back the code as syscall retval */
698             if (code < 0) {
699                 *retval = code;
700                 code = 0;
701             }
702 #endif
703         } else if (uap->syscall == AFSCALL_SETPAG) {
704 #ifdef  AFS_SUN5_ENV
705             register proc_t *procp;
706
707             procp = ttoproc(curthread);
708             AFS_GLOCK();
709             code = afs_setpag(&procp->p_cred);
710             AFS_GUNLOCK();
711 #else
712             AFS_GLOCK();
713 #if     defined(AFS_FBSD_ENV)
714             code = afs_setpag(p, args);
715 #elif   defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
716             code = afs_setpag(p, args, retval);
717 #else /* AFS_DARWIN_ENV || AFS_XBSD_ENV */
718             code = afs_setpag();
719 #endif
720             AFS_GUNLOCK();
721 #endif
722         } else if (uap->syscall == AFSCALL_PIOCTL) {
723             AFS_GLOCK();
724 #if defined(AFS_SUN5_ENV)
725             code =
726                 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
727                                    uap->parm4, rvp, CRED());
728 #elif defined(AFS_FBSD50_ENV)
729             code =
730                 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
731                                    uap->parm4, p->td_ucred);
732 #elif defined(AFS_DARWIN80_ENV)
733             code =
734                 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
735                                    uap->parm4, kauth_cred_get());
736 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
737             code =
738                 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
739                                    uap->parm4, p->p_cred->pc_ucred);
740 #else
741             code =
742                 afs_syscall_pioctl((char *)uap->parm1,
743                                    (unsigned int)uap->parm2,
744                                    (caddr_t)uap->parm3,
745                                    (int) uap->parm4);
746 #endif
747             AFS_GUNLOCK();
748         } else if (uap->syscall == AFSCALL_ICREATE) {
749             struct iparam iparams;
750
751             code = copyin_iparam((char *)uap->parm3, &iparams);
752             if (code) {
753 #if defined(KERNEL_HAVE_UERROR)
754                 setuerror(code);
755 #endif
756             } else {
757 #ifdef  AFS_SUN5_ENV
758                 code =
759                     afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1,
760                                         iparams.param2, iparams.param3,
761                                         iparams.param4, rvp, CRED());
762 #else
763                 code =
764                     afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1,
765                                         iparams.param2, iparams.param3,
766                                         iparams.param4
767 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
768                                         , retval
769 #endif
770                         );
771 #endif /* AFS_SUN5_ENV */
772             }
773         } else if (uap->syscall == AFSCALL_IOPEN) {
774 #ifdef  AFS_SUN5_ENV
775             code =
776                 afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3, rvp,
777                                   CRED());
778 #else
779             code = afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3
780 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
781                                      , retval
782 #endif
783                 );
784 #endif /* AFS_SUN5_ENV */
785         } else if (uap->syscall == AFSCALL_IDEC) {
786             code =
787                 afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, -1
788 #ifdef  AFS_SUN5_ENV
789                                     , rvp, CRED()
790 #endif
791                     );
792         } else if (uap->syscall == AFSCALL_IINC) {
793             code =
794                 afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, 1
795 #ifdef  AFS_SUN5_ENV
796                                     , rvp, CRED()
797 #endif
798                     );
799         } else if (uap->syscall == AFSCALL_ICL) {
800             AFS_GLOCK();
801             code =
802                 Afscall_icl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
803                             uap->parm5, (long *)retval);
804             AFS_GUNLOCK();
805 #ifdef AFS_LINUX20_ENV
806             if (!code) {
807                 /* ICL commands can return values. */
808                 code = -linux_ret;      /* Gets negated again at exit below */
809             }
810 #else
811             if (code) {
812 #if defined(KERNEL_HAVE_UERROR)
813                 setuerror(code);
814 #endif
815             }
816 #endif /* !AFS_LINUX20_ENV */
817         } else {
818 #if defined(KERNEL_HAVE_UERROR)
819             setuerror(EINVAL);
820 #else
821             code = EINVAL;
822 #endif
823         }
824 #if defined(AFS_DARWIN80_ENV)
825         if (uap->syscall != AFSCALL_CALL)
826             put_vfs_context();
827 #ifdef AFS_DARWIN100_ENV
828     } /* 32 bit procs */
829 #endif
830 #endif
831 #ifdef AFS_LINUX20_ENV
832     code = -code;
833     unlock_kernel();
834 #endif
835     return code;
836 }
837 #endif /* AFS_SGI_ENV */
838 #endif /* !AFS_AIX32_ENV */