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