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((void *)uap->parm1, uap->parm2, (void *)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 */