2 * Copyright 2000, International Business Machines Corporation and others.
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
10 #include <afsconfig.h>
11 #include "afs/param.h"
13 #ifdef IGNORE_SOME_GCC_WARNINGS
14 # pragma GCC diagnostic warning "-Wold-style-definition"
15 # pragma GCC diagnostic warning "-Wstrict-prototypes"
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)
25 #include "h/hashing.h"
27 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN_ENV)
28 #include "netinet/in_var.h"
30 #endif /* !defined(UKERNEL) */
31 #ifdef AFS_LINUX22_ENV
32 #include "h/smp_lock.h"
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)
37 afs_ioctl32_to_afs_ioctl(const struct afs_ioctl32 *src, struct afs_ioctl *dst)
39 #ifdef AFS_DARWIN100_ENV
40 dst->in = CAST_USER_ADDR_T(src->in);
41 dst->out = CAST_USER_ADDR_T(src->out);
43 dst->in = (char *)(unsigned long)src->in;
44 dst->out = (char *)(unsigned long)src->out;
46 dst->in_size = src->in_size;
47 dst->out_size = src->out_size;
52 * If you need to change copyin_afs_ioctl(), you may also need to change
57 #ifdef AFS_DARWIN100_ENV
58 copyin_afs_ioctl(user_addr_t cmarg, struct afs_ioctl *dst)
60 copyin_afs_ioctl(caddr_t cmarg, struct afs_ioctl *dst)
64 #if defined(AFS_DARWIN100_ENV)
65 struct afs_ioctl32 dst32;
67 if (!proc_is64bit(current_proc())) {
68 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
70 afs_ioctl32_to_afs_ioctl(&dst32, dst);
74 #if defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)
75 struct afs_ioctl32 dst32;
78 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
80 afs_ioctl32_to_afs_ioctl(&dst32, dst);
83 #endif /* defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL) */
86 #if defined(AFS_HPUX_64BIT_ENV)
87 struct afs_ioctl32 dst32;
89 if (is_32bit(u.u_procp)) { /* is_32bit() in proc_iface.h */
90 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
92 afs_ioctl32_to_afs_ioctl(&dst32, dst);
95 #endif /* defined(AFS_HPUX_64BIT_ENV) */
97 #if defined(AFS_SUN57_64BIT_ENV)
98 struct afs_ioctl32 dst32;
100 if (get_udatamodel() == DATAMODEL_ILP32) {
101 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
103 afs_ioctl32_to_afs_ioctl(&dst32, dst);
106 #endif /* defined(AFS_SUN57_64BIT_ENV) */
108 #if defined(AFS_SGI_ENV) && (_MIPS_SZLONG==64)
109 struct afs_ioctl32 dst32;
111 if (!ABI_IS_64BIT(get_current_abi())) {
112 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
114 afs_ioctl32_to_afs_ioctl(&dst32, dst);
117 #endif /* defined(AFS_SGI_ENV) && (_MIPS_SZLONG==64) */
119 #if defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_ALPHA_LINUX20_ENV) && !defined(AFS_IA64_LINUX20_ENV)
120 struct afs_ioctl32 dst32;
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)
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)
134 #elif defined(AFS_PPC64_LINUX26_ENV)
135 #if defined(STRUCT_TASK_STRUCT_HAS_THREAD_INFO)
136 if (current->thread_info->flags & _TIF_32BIT)
138 if (task_thread_info(current)->flags & _TIF_32BIT)
140 #elif defined(AFS_PPC64_LINUX20_ENV)
141 if (current->thread.flags & PPC_FLAG_32BIT)
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)
149 #error pioctl32 not done for this linux
152 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
154 afs_ioctl32_to_afs_ioctl(&dst32, dst);
157 #endif /* defined(AFS_LINUX_64BIT_KERNEL) */
159 AFS_COPYIN(cmarg, (caddr_t) dst, sizeof *dst, code);
166 #include "sys/lockl.h"
169 * syscall - this is the VRMIX system call entry point.
172 * THIS SHOULD BE CHANGED TO afs_syscall(), but requires
173 * all the user-level calls to `syscall' to change.
175 syscall(syscall, p1, p2, p3, p4, p5, p6)
177 register rval1 = 0, code;
180 #ifndef AFS_AIX41_ENV
181 extern lock_t kernel_lock;
182 monster = lockl(&kernel_lock, LOCK_SHORT);
183 #endif /* !AFS_AIX41_ENV */
185 AFS_STATCNT(syscall);
189 rval1 = afs_syscall_call(p1, p2, p3, p4, p5, p6);
194 rval1 = afs_setpag();
200 rval1 = afs_syscall_pioctl(p1, p2, p3, p4);
204 case AFSCALL_ICREATE:
205 rval1 = afs_syscall_icreate(p1, p2, p3, p4, p5, p6);
209 rval1 = afs_syscall_iopen(p1, p2, p3);
213 rval1 = afs_syscall_iincdec(p1, p2, p3, -1);
217 rval1 = afs_syscall_iincdec(p1, p2, p3, 1);
222 code = Afscall_icl(p1, p2, p3, p4, p5, &retval);
237 #ifndef AFS_AIX41_ENV
238 if (monster != LOCK_NEST)
239 unlockl(&kernel_lock);
240 #endif /* !AFS_AIX41_ENV */
241 return getuerror()? -1 : rval1;
245 * lsetpag - interface to afs_setpag().
251 AFS_STATCNT(lsetpag);
252 return syscall(AFSCALL_SETPAG, 0, 0, 0, 0, 0);
256 * lpioctl - interface to pioctl()
259 lpioctl(char *path, int cmd, void *cmarg, int follow)
262 AFS_STATCNT(lpioctl);
263 return syscall(AFSCALL_PIOCTL, path, cmd, cmarg, follow);
266 #else /* !AFS_AIX32_ENV */
268 #if defined(AFS_SGI_ENV)
280 Afs_syscall(struct afsargs *uap, rval_t * rvp)
285 AFS_STATCNT(afs_syscall);
286 switch (uap->syscall) {
291 Afscall_icl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
292 uap->parm5, &retval);
294 rvp->r_val1 = retval;
296 #ifdef AFS_SGI_XFS_IOPS_ENV
299 afs_syscall_idec64(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
304 afs_syscall_iinc64(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
307 case AFSCALL_ILISTINODE64:
309 afs_syscall_ilistinode64(uap->parm1, uap->parm2, uap->parm3,
310 uap->parm4, uap->parm5);
312 case AFSCALL_ICREATENAME64:
314 afs_syscall_icreatename64(uap->parm1, uap->parm2, uap->parm3,
315 uap->parm4, uap->parm5);
318 #ifdef AFS_SGI_VNODE_GLUE
319 case AFSCALL_INIT_KERNEL_CONFIG:
320 error = afs_init_kernel_config(uap->parm1);
325 afs_syscall_call(uap->syscall, uap->parm1, uap->parm2, uap->parm3,
326 uap->parm4, uap->parm5);
331 #else /* AFS_SGI_ENV */
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)
350 iparam32_to_iparam(const struct iparam32 *src, struct iparam *dst)
352 dst->param1 = (iparmtype)(uintptrsz)src->param1;
353 dst->param2 = (iparmtype)(uintptrsz)src->param2;
354 dst->param3 = (iparmtype)(uintptrsz)src->param3;
355 dst->param4 = (iparmtype)(uintptrsz)src->param4;
360 * If you need to change copyin_iparam(), you may also need to change
361 * copyin_afs_ioctl().
363 * This function is needed only for icreate, meaning, only on platforms
364 * providing the inode fileserver.
368 copyin_iparam(caddr_t cmarg, struct iparam *dst)
372 #if defined(AFS_HPUX_64BIT_ENV)
373 struct iparam32 dst32;
375 if (is_32bit(u.u_procp)) { /* is_32bit() in proc_iface.h */
376 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
378 iparam32_to_iparam(&dst32, dst);
381 #endif /* AFS_HPUX_64BIT_ENV */
383 #if defined(AFS_SUN57_64BIT_ENV)
384 struct iparam32 dst32;
386 if (get_udatamodel() == DATAMODEL_ILP32) {
387 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
389 iparam32_to_iparam(&dst32, dst);
392 #endif /* AFS_SUN57_64BIT_ENV */
394 #if defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_ALPHA_LINUX20_ENV) && !defined(AFS_IA64_LINUX20_ENV)
395 struct iparam32 dst32;
397 #ifdef AFS_SPARC64_LINUX26_ENV
398 if (test_thread_flag(TIF_32BIT))
399 #elif defined(AFS_SPARC64_LINUX24_ENV)
400 if (current->thread.flags & SPARC_FLAG_32BIT)
401 #elif defined(AFS_SPARC64_LINUX20_ENV)
402 if (current->tss.flags & SPARC_FLAG_32BIT)
404 #elif defined(AFS_AMD64_LINUX26_ENV)
405 if (test_thread_flag(TIF_IA32))
406 #elif defined(AFS_AMD64_LINUX20_ENV)
407 if (current->thread.flags & THREAD_IA32)
409 #elif defined(AFS_PPC64_LINUX26_ENV)
410 #if defined(STRUCT_TASK_STRUCT_HAS_THREAD_INFO)
411 if (current->thread_info->flags & _TIF_32BIT)
413 if (task_thread_info(current)->flags & _TIF_32BIT)
415 #elif defined(AFS_PPC64_LINUX20_ENV)
416 if (current->thread.flags & PPC_FLAG_32BIT)
418 #elif defined(AFS_S390X_LINUX26_ENV)
419 if (test_thread_flag(TIF_31BIT))
420 #elif defined(AFS_S390X_LINUX20_ENV)
421 if (current->thread.flags & S390_FLAG_31BIT)
424 #error iparam32 not done for this linux platform
427 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code);
429 iparam32_to_iparam(&dst32, dst);
432 #endif /* AFS_LINUX_64BIT_KERNEL */
434 AFS_COPYIN(cmarg, (caddr_t) dst, sizeof *dst, code);
438 /* Main entry of all afs system calls */
440 extern int afs_sinited;
442 /** The 32 bit OS expects the members of this structure to be 32 bit
443 * quantities and the 64 bit OS expects them as 64 bit quanties. Hence
444 * to accomodate both, *long* is used instead of afs_int32
447 # ifdef AFS_SUN57_ENV
469 Afs_syscall(register struct afssysa *uap, rval_t * rvp)
471 int *retval = &rvp->r_val1;
472 #elif defined(AFS_DARWIN100_ENV)
492 afs3_syscall(afs_proc_t *p, void *args, unsigned int *retval)
494 struct afssysa64 *uap64 = NULL;
495 struct afssysa *uap = NULL;
496 #elif defined(AFS_FBSD_ENV)
498 afs3_syscall(struct thread *p, void *args)
508 } *uap = (struct a *)args;
510 #elif defined(AFS_NBSD40_ENV)
512 afs3_syscall(struct lwp *p, void *args)
514 /* see osi_machdep.h */
515 struct afs_sysargs *uap = (struct afs_sysargs *) args;
517 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
519 afs3_syscall(afs_proc_t *p, void *args, long *retval)
529 } *uap = (struct a *)args;
530 #elif defined(AFS_LINUX20_ENV)
538 long parm6; /* not actually used - should be removed */
540 /* Linux system calls only set up for 5 arguments. */
542 afs_syscall(long syscall, long parm1, long parm2, long parm3, long parm4)
544 struct afssysargs args, *uap = &args;
546 long *retval = &linux_ret;
547 long eparm[4]; /* matches AFSCALL_ICL in fstrace.c */
548 # ifdef AFS_SPARC64_LINUX24_ENV
549 afs_int32 eparm32[4];
551 /* eparm is also used by AFSCALL_CALL in afsd.c */
553 # if defined(UKERNEL)
565 } *uap = (struct a *)get_user_struct()->u_ap;
578 } *uap = (struct a *)u.u_ap;
579 # endif /* UKERNEL */
580 # if defined(AFS_HPUX_ENV)
581 long *retval = &u.u_rval1;
582 # elif defined(UKERNEL)
583 int *retval = &(get_user_struct()->u_rval1);
585 int *retval = &u.u_rval1;
588 register int code = 0;
590 AFS_STATCNT(afs_syscall);
597 #ifdef AFS_LINUX20_ENV
599 /* setup uap for use below - pull out the magic decoder ring to know
600 * which syscalls have folded argument lists.
602 uap->syscall = syscall;
606 if (syscall == AFSCALL_ICL || syscall == AFSCALL_CALL) {
607 #ifdef AFS_SPARC64_LINUX24_ENV
608 /* from arch/sparc64/kernel/sys_sparc32.c */
610 ({ unsigned long __ret; \
611 __asm__ ("srl %0, 0, %0" \
618 #ifdef AFS_SPARC64_LINUX26_ENV
619 if (test_thread_flag(TIF_32BIT))
621 if (current->thread.flags & SPARC_FLAG_32BIT)
624 AFS_COPYIN((char *)parm4, (char *)eparm32, sizeof(eparm32), code);
625 eparm[0] = AA(eparm32[0]);
626 eparm[1] = AA(eparm32[1]);
627 eparm[2] = AA(eparm32[2]);
631 AFS_COPYIN((char *)parm4, (char *)eparm, sizeof(eparm), code);
632 uap->parm4 = eparm[0];
633 uap->parm5 = eparm[1];
634 uap->parm6 = eparm[2];
641 #if defined(AFS_DARWIN80_ENV)
643 osi_Assert(*retval == 0);
644 #ifdef AFS_DARWIN100_ENV
645 if (proc_is64bit(p)) {
646 uap64 = (struct afssysa64 *)args;
647 if (uap64->syscall == AFSCALL_CALL) {
649 afs_syscall64_call(uap64->parm1, uap64->parm2, uap64->parm3,
650 uap64->parm4, uap64->parm5, uap64->parm6);
651 /* pass back the code as syscall retval */
656 } else if (uap64->syscall == AFSCALL_SETPAG) {
658 code = afs_setpag(p, args, retval);
660 } else if (uap64->syscall == AFSCALL_PIOCTL) {
663 afs_syscall64_pioctl(uap64->parm1, (unsigned int)uap64->parm2,
664 uap64->parm3, (int)uap64->parm4,
667 } else if (uap64->syscall == AFSCALL_ICL) {
670 Afscall64_icl(uap64->parm1, uap64->parm2, uap64->parm3,
671 uap64->parm4, uap64->parm5, retval);
675 if (uap64->syscall != AFSCALL_CALL)
677 } else { /* and the default case for 32 bit procs */
679 uap = (struct afssysa *)args;
681 #if defined(AFS_HPUX_ENV)
683 * There used to be code here (duplicated from osi_Init()) for
684 * initializing the semaphore used by AFS_GLOCK(). Was the
685 * duplication to handle the case of a dynamically loaded kernel
691 #if defined(AFS_NBSD40_ENV)
692 if (SCARG(uap, syscall) == AFSCALL_CALL) {
694 afs_syscall_call(SCARG(uap, parm1), SCARG(uap, parm2),
695 SCARG(uap, parm3), SCARG(uap, parm4),
696 SCARG(uap, parm5), SCARG(uap, parm6));
697 } else if (SCARG(uap, syscall) == AFSCALL_SETPAG) {
699 if (uap->syscall == AFSCALL_CALL) {
701 afs_syscall_call(uap->parm1, uap->parm2, uap->parm3,
702 uap->parm4, uap->parm5, uap->parm6);
703 #ifdef AFS_DARWIN_ENV
704 /* pass back the code as syscall retval */
710 } else if (uap->syscall == AFSCALL_SETPAG) {
713 register proc_t *procp;
715 procp = ttoproc(curthread);
717 code = afs_setpag(&procp->p_cred);
721 #if defined(AFS_FBSD_ENV)
722 code = afs_setpag(p, args);
723 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
724 code = afs_setpag(p, args, retval);
725 #else /* AFS_DARWIN_ENV || AFS_XBSD_ENV */
731 #if defined(AFS_NBSD40_ENV)
732 (SCARG(uap, syscall) == AFSCALL_PIOCTL) {
734 (uap->syscall == AFSCALL_PIOCTL) {
737 #if defined(AFS_SUN5_ENV)
739 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
740 uap->parm4, rvp, CRED());
741 #elif defined(AFS_FBSD_ENV)
743 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
744 uap->parm4, p->td_ucred);
745 #elif defined(AFS_DARWIN80_ENV)
747 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
748 uap->parm4, kauth_cred_get());
749 #elif defined(AFS_NBSD40_ENV)
751 afs_syscall_pioctl(SCARG(uap, parm1), SCARG(uap, parm2),
752 SCARG(uap, parm3), SCARG(uap, parm4),
754 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
756 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
757 uap->parm4, p->p_cred->pc_ucred);
760 afs_syscall_pioctl((char *)uap->parm1,
761 (unsigned int)uap->parm2,
767 #ifdef AFS_NBSD40_ENV
768 } else if (SCARG(uap, syscall) == AFSCALL_ICREATE) {
769 struct iparam iparams;
770 code = copyin_iparam((char *) SCARG(uap, parm3), &iparams);
772 } else if (uap->syscall == AFSCALL_ICREATE) {
773 struct iparam iparams;
775 code = copyin_iparam((char *)uap->parm3, &iparams);
778 #if defined(KERNEL_HAVE_UERROR)
782 #if defined(AFS_SUN5_ENV)
784 afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1,
785 iparams.param2, iparams.param3,
786 iparams.param4, rvp, CRED());
787 #elif defined(AFS_NBSD40_ENV)
789 code = afs_syscall_create(SCARG(uap, parm1), SCARG(uap, parm2),
790 SCARG(uap, parm3), SCARG(uap, parm4),
794 afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1,
795 iparams.param2, iparams.param3,
797 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
801 #endif /* AFS_SUN5_ENV */
803 #if defined(AFS_NBSD40_ENV)
804 } else if (SCARG(uap, syscall) == AFSCALL_IOPEN) {
806 } else if (uap->syscall == AFSCALL_IOPEN) {
807 #endif /* !AFS_NBSD40_ENV */
808 #if defined(AFS_SUN5_ENV)
810 afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3, rvp,
812 #elif defined(AFS_NBSD40_ENV)
813 code = afs_syscall_iopen(SCARG(uap, parm1), SCARG(uap, parm2),
814 SCARG(uap, parm3), retval);
816 code = afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3
817 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
821 #endif /* AFS_SUN5_ENV */
822 #if defined(AFS_NBSD40_ENV)
823 } else if (SCARG(uap, syscall) == AFSCALL_IDEC) {
825 } else if (uap->syscall == AFSCALL_IDEC) {
827 #if defined(AFS_NBSD40_ENV)
828 code = afs_syscall_iincdec(SCARG(uap, parm1), SCARG(uap, parm2),
829 SCARG(uap, parm3), -1);
834 afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, -1
835 #if defined(AFS_SUN5_ENV)
840 #endif /* !AFS_NBSD40_ENV */
841 #if defined(AFS_NBSD40_ENV)
842 } else if (SCARG(uap, syscall) == AFSCALL_IINC) {
844 } else if (uap->syscall == AFSCALL_IINC) {
846 #if defined(AFS_NBSD40_ENV)
847 code = afs_syscall_iincdec(SCARG(uap, parm1), SCARG(uap, parm2),
848 SCARG(uap, parm3), 1);
851 afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, 1
856 #endif /* !AFS_NBSD40_ENV */
857 #if defined(AFS_NBSD40_ENV)
858 } else if (SCARG(uap, syscall) == AFSCALL_ICL) {
860 } else if (uap->syscall == AFSCALL_ICL) {
864 #if defined(AFS_NBSD40_ENV)
865 Afscall_icl(SCARG(uap, parm1), SCARG(uap, parm2),
866 SCARG(uap, parm3), SCARG(uap, parm4),
867 SCARG(uap, parm5), retval);
869 Afscall_icl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
870 uap->parm5, (long *)retval);
871 #endif /* !AFS_NBSD40_ENV */
873 #ifdef AFS_LINUX20_ENV
875 /* ICL commands can return values. */
876 code = -linux_ret; /* Gets negated again at exit below */
880 #if defined(KERNEL_HAVE_UERROR)
884 #endif /* !AFS_LINUX20_ENV */
886 #if defined(KERNEL_HAVE_UERROR)
892 #if defined(AFS_DARWIN80_ENV)
893 if (uap->syscall != AFSCALL_CALL)
895 #ifdef AFS_DARWIN100_ENV
899 #ifdef AFS_LINUX20_ENV
905 #endif /* AFS_SGI_ENV */
906 #endif /* !AFS_AIX32_ENV */