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