From 81099c479e148a103dcf9f4def125b28e989107c Mon Sep 17 00:00:00 2001 From: Derrick Brashear Date: Wed, 26 Aug 2009 17:34:50 -0400 Subject: [PATCH] macos 10.6 64 bit support support 64 bit userland with 32 bit kernel, and 32 and 64 bit userland with 64 kit kernel Reviewed-on: http://gerrit.openafs.org/343 Reviewed-by: Derrick Brashear Tested-by: Derrick Brashear --- src/afs/AIX/osi_machdep.h | 4 + src/afs/DARWIN/osi_groups.c | 9 +- src/afs/DARWIN/osi_machdep.h | 12 +- src/afs/DARWIN/osi_misc.c | 222 +++++++++++++++++------------- src/afs/DARWIN/osi_prototypes.h | 2 + src/afs/DARWIN/osi_vm.c | 6 +- src/afs/DARWIN/osi_vnodeops.c | 4 +- src/afs/FBSD/osi_machdep.h | 3 + src/afs/HPUX/osi_machdep.h | 2 + src/afs/IRIX/osi_machdep.h | 3 + src/afs/LINUX/osi_machdep.h | 3 + src/afs/LINUX/osi_misc.c | 3 +- src/afs/NBSD/osi_machdep.h | 2 + src/afs/OBSD/osi_machdep.h | 4 + src/afs/SOLARIS/osi_machdep.h | 2 + src/afs/UKERNEL/osi_machdep.h | 2 + src/afs/afs.h | 10 +- src/afs/afs_call.c | 134 ++++++++++++------- src/afs/afs_icl.c | 41 +++++- src/afs/afs_osi.h | 4 +- src/afs/afs_osi_pag.c | 6 +- src/afs/afs_pioctl.c | 25 +++- src/afs/afs_prototypes.h | 19 ++- src/afs/afs_syscall.c | 267 ++++++++++++++++++++++--------------- src/afs/afs_vcache.c | 2 +- src/afsd/afsd.c | 55 ++++++-- src/cf/osconf.m4 | 2 +- src/config/afs_args.h | 29 ++-- src/libafs/MakefileProto.DARWIN.in | 11 +- src/rx/rx_clock.h | 2 +- src/sys/glue.c | 67 +++++++--- src/sys/setpag.c | 2 + 32 files changed, 631 insertions(+), 328 deletions(-) diff --git a/src/afs/AIX/osi_machdep.h b/src/afs/AIX/osi_machdep.h index 9033fd1..a1658db 100644 --- a/src/afs/AIX/osi_machdep.h +++ b/src/afs/AIX/osi_machdep.h @@ -41,6 +41,10 @@ extern long time; #define gop_lookupname(fnamep,segflg,followlink,compvpp) \ lookupvp((fnamep), (followlink), (compvpp), &afs_osi_cred) +#undef gop_lookupname_user +#define gop_lookupname_user(fnamep,segflg,followlink,compvpp) \ + lookupvp((fnamep), (followlink), (compvpp), &afs_osi_cred) + #undef afs_suser #undef setuerror diff --git a/src/afs/DARWIN/osi_groups.c b/src/afs/DARWIN/osi_groups.c index 4e1f381..11e65e3 100644 --- a/src/afs/DARWIN/osi_groups.c +++ b/src/afs/DARWIN/osi_groups.c @@ -16,7 +16,9 @@ */ #include #include "afs/param.h" - +#include "afs/sysincludes.h" +#include "afsincludes.h" +#include "afs/afs_stats.h" /* statistics */ /* We should be doing something better anyway */ #ifdef AFS_DARWIN80_ENV @@ -28,12 +30,9 @@ setpag(proc, cred, pagvalue, newpag, change_parent) afs_uint32 *newpag; afs_uint32 change_parent; { - return -1; + return EINVAL; } #else -#include "afs/sysincludes.h" -#include "afsincludes.h" -#include "afs/afs_stats.h" /* statistics */ static int afs_getgroups(struct ucred *cred, int ngroups, gid_t * gidset); diff --git a/src/afs/DARWIN/osi_machdep.h b/src/afs/DARWIN/osi_machdep.h index fc13ade..d13760c 100644 --- a/src/afs/DARWIN/osi_machdep.h +++ b/src/afs/DARWIN/osi_machdep.h @@ -57,6 +57,8 @@ typedef unsigned short etap_event_t; #endif #undef gop_lookupname #define gop_lookupname osi_lookupname +#undef gop_lookupname_user +#define gop_lookupname_user osi_lookupname_user #define FTRUNC 0 @@ -101,9 +103,17 @@ enum vcexcl { EXCL, NONEXCL }; #define crref kauth_cred_get_with_ref #define crhold kauth_cred_ref +#ifdef AFS_DARWIN100_ENV +#define crfree(X) kauth_cred_unref(&X) +#else #define crfree kauth_cred_rele +#endif #define crdup kauth_cred_dup - +#ifdef AFS_DARWIN100_ENV +#define ubc_msync_range(X,Y,Z,A) ubc_msync(X,Y,Z,NULL,A) +#else +#define ubc_msync_range(X,Y,Z,A) ubc_sync_range(X,Y,Z,A) +#endif extern vfs_context_t afs_osi_ctxtp; extern int afs_osi_ctxtp_initialized; #endif diff --git a/src/afs/DARWIN/osi_misc.c b/src/afs/DARWIN/osi_misc.c index f990fab..076d567 100644 --- a/src/afs/DARWIN/osi_misc.c +++ b/src/afs/DARWIN/osi_misc.c @@ -21,19 +21,28 @@ #ifdef AFS_DARWIN80_ENV int -osi_lookupname(char *aname, enum uio_seg seg, int followlink, - struct vnode **vpp) { - vfs_context_t ctx; +osi_lookupname_user(user_addr_t aname, enum uio_seg seg, int followlink, + struct vnode **vpp) { char tname[PATHBUFLEN]; - int code, flags; size_t len; - + int code; + if (seg == AFS_UIOUSER) { /* XXX 64bit */ AFS_COPYINSTR(aname, tname, sizeof(tname), &len, code); if (code) return code; - aname=tname; - } + return osi_lookupname(tname, seg, followlink, vpp); + } else + return osi_lookupname(CAST_DOWN(char *, aname), seg, followlink, vpp); + +} + +int +osi_lookupname(char *aname, enum uio_seg seg, int followlink, + struct vnode **vpp) { + vfs_context_t ctx; + int code, flags; + flags = 0; if (!followlink) flags |= VNODE_LOOKUP_NOFOLLOW; @@ -94,32 +103,34 @@ afs_suser(void *credp) } #ifdef AFS_DARWIN80_ENV -uio_t afsio_darwin_partialcopy(uio_t auio, int size) { - uio_t res; - int i; - user_addr_t iovaddr; - user_size_t iovsize; - - if (proc_is64bit(current_proc())) { - res = uio_create(uio_iovcnt(auio), uio_offset(auio), - uio_isuserspace(auio) ? UIO_USERSPACE64 : UIO_SYSSPACE32, - uio_rw(auio)); - } else { - res = uio_create(uio_iovcnt(auio), uio_offset(auio), - uio_isuserspace(auio) ? UIO_USERSPACE32 : UIO_SYSSPACE32, - uio_rw(auio)); - } - - for (i = 0;i < uio_iovcnt(auio) && size > 0;i++) { - if (uio_getiov(auio, i, &iovaddr, &iovsize)) - break; - if (iovsize > size) - iovsize = size; - if (uio_addiov(res, iovaddr, iovsize)) - break; - size -= iovsize; - } - return res; +uio_t +afsio_darwin_partialcopy(uio_t auio, int size) +{ + uio_t res; + int i; + user_addr_t iovaddr; + user_size_t iovsize; + + if (proc_is64bit(current_proc())) { + res = uio_create(uio_iovcnt(auio), uio_offset(auio), + uio_isuserspace(auio) ? UIO_USERSPACE64 : UIO_SYSSPACE32, + uio_rw(auio)); + } else { + res = uio_create(uio_iovcnt(auio), uio_offset(auio), + uio_isuserspace(auio) ? UIO_USERSPACE32 : UIO_SYSSPACE32, + uio_rw(auio)); + } + + for (i = 0;i < uio_iovcnt(auio) && size > 0;i++) { + if (uio_getiov(auio, i, &iovaddr, &iovsize)) + break; + if (iovsize > size) + iovsize = size; + if (uio_addiov(res, iovaddr, iovsize)) + break; + size -= iovsize; + } + return res; } vfs_context_t afs_osi_ctxtp; @@ -127,81 +138,108 @@ int afs_osi_ctxtp_initialized; static thread_t vfs_context_owner; static proc_t vfs_context_curproc; int vfs_context_ref; -void get_vfs_context(void) { - int isglock = ISAFS_GLOCK(); - if (!isglock) - AFS_GLOCK(); - if (afs_osi_ctxtp_initialized) { - if (!isglock) - AFS_GUNLOCK(); - return; - } - osi_Assert(vfs_context_owner != current_thread()); - if (afs_osi_ctxtp && current_proc() == vfs_context_curproc) { - vfs_context_ref++; - vfs_context_owner = current_thread(); - if (!isglock) - AFS_GUNLOCK(); - return; - } - while (afs_osi_ctxtp && vfs_context_ref) { - afs_osi_Sleep(&afs_osi_ctxtp); - if (afs_osi_ctxtp_initialized) { - if (!isglock) - AFS_GUNLOCK(); - return; - } - } - vfs_context_rele(afs_osi_ctxtp); - vfs_context_ref=1; - afs_osi_ctxtp = vfs_context_create(NULL); - vfs_context_owner = current_thread(); - vfs_context_curproc = current_proc(); - if (!isglock) - AFS_GUNLOCK(); +void +get_vfs_context(void) +{ + int isglock = ISAFS_GLOCK(); + + if (!isglock) + AFS_GLOCK(); + if (afs_osi_ctxtp_initialized) { + if (!isglock) + AFS_GUNLOCK(); + return; + } + osi_Assert(vfs_context_owner != current_thread()); + if (afs_osi_ctxtp && current_proc() == vfs_context_curproc) { + vfs_context_ref++; + vfs_context_owner = current_thread(); + if (!isglock) + AFS_GUNLOCK(); + return; + } + while (afs_osi_ctxtp && vfs_context_ref) { + afs_osi_Sleep(&afs_osi_ctxtp); + if (afs_osi_ctxtp_initialized) { + if (!isglock) + AFS_GUNLOCK(); + return; + } + } + vfs_context_rele(afs_osi_ctxtp); + vfs_context_ref=1; + afs_osi_ctxtp = vfs_context_create(NULL); + vfs_context_owner = current_thread(); + vfs_context_curproc = current_proc(); + if (!isglock) + AFS_GUNLOCK(); } -void put_vfs_context(void) { - int isglock = ISAFS_GLOCK(); - - if (!isglock) - AFS_GLOCK(); - if (afs_osi_ctxtp_initialized) { - if (!isglock) - AFS_GUNLOCK(); - return; - } - if (vfs_context_owner == current_thread()) - vfs_context_owner = (thread_t)0; - vfs_context_ref--; - afs_osi_Wakeup(&afs_osi_ctxtp); - if (!isglock) +void +put_vfs_context(void) +{ + int isglock = ISAFS_GLOCK(); + + if (!isglock) + AFS_GLOCK(); + if (afs_osi_ctxtp_initialized) { + if (!isglock) + AFS_GUNLOCK(); + return; + } + if (vfs_context_owner == current_thread()) + vfs_context_owner = (thread_t)0; + vfs_context_ref--; + afs_osi_Wakeup(&afs_osi_ctxtp); + if (!isglock) AFS_GUNLOCK(); } -extern int afs3_syscall(); - -int afs_cdev_nop_openclose(dev_t dev, int flags, int devtype,struct proc *p) { - return 0; +int +afs_cdev_nop_openclose(dev_t dev, int flags, int devtype,struct proc *p) +{ + return 0; } -extern int afs3_syscall(struct proc *p, void *data, unsigned long *retval); + +extern int afs3_syscall(struct proc *p, void *data, unsigned int *retval); int afs_cdev_ioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) { - unsigned long retval=0; - int code; + unsigned int retval=0; + int code, is64 = proc_is64bit(p); struct afssysargs *a = (struct afssysargs *)data; - - if (cmd != VIOC_SYSCALL) { + struct afssysargs64 *a64 = (struct afssysargs64 *)data; + + if (((unsigned int)cmd != VIOC_SYSCALL) && + ((unsigned int)cmd != VIOC_SYSCALL64)) + return EINVAL; + + if (((unsigned int)cmd == VIOC_SYSCALL64) && (is64 == 0)) + return EINVAL; + + if (((unsigned int)cmd == VIOC_SYSCALL) && (is64 != 0)) return EINVAL; - } code=afs3_syscall(p, data, &retval); if (code) return code; - if (retval && a->syscall != AFSCALL_CALL && a->param1 != AFSOP_CACHEINODE) { printf("SSCall(%d,%d) is returning non-error value %d\n", a->syscall, a->param1, retval); } - a->retval = retval; + + if ((!is64) && retval && a->syscall != AFSCALL_CALL + && a->param1 != AFSOP_CACHEINODE) + { + printf("SSCall(%d,%d) is returning non-error value %d\n", a->syscall, a->param1, retval); + } + if ((is64) && retval && a64->syscall != AFSCALL_CALL + && a64->param1 != AFSOP_CACHEINODE) + { + printf("SSCall(%d,%llx) is returning non-error value %d\n", a64->syscall, a64->param1, retval); + } + + if (!is64) + a->retval = retval; + else + a64->retval = retval; return 0; } diff --git a/src/afs/DARWIN/osi_prototypes.h b/src/afs/DARWIN/osi_prototypes.h index a5a5ccd..4a9b6b2 100644 --- a/src/afs/DARWIN/osi_prototypes.h +++ b/src/afs/DARWIN/osi_prototypes.h @@ -20,6 +20,8 @@ extern afs_rwlock_t afs_xosi; /* osi_misc.c */ extern int osi_lookupname(char *aname, enum uio_seg seg, int followlink, struct vnode **vpp); +extern int osi_lookupname_user(user_addr_t aname, enum uio_seg seg, + int followlink, struct vnode **vpp); extern int afs_suser(void *credp); extern void get_vfs_context(void); extern void put_vfs_context(void); diff --git a/src/afs/DARWIN/osi_vm.c b/src/afs/DARWIN/osi_vm.c index e7a708e..a266c08 100644 --- a/src/afs/DARWIN/osi_vm.c +++ b/src/afs/DARWIN/osi_vm.c @@ -67,7 +67,7 @@ osi_VM_StoreAllSegments(struct vcache *avc) ReleaseWriteLock(&avc->lock); AFS_GUNLOCK(); #ifdef AFS_DARWIN80_ENV - ubc_sync_range(vp, 0, ubc_getsize(vp), UBC_SYNC|UBC_PUSHDIRTY); + ubc_msync_range(vp, 0, ubc_getsize(vp), UBC_SYNC|UBC_PUSHDIRTY); #else if (UBCINFOEXISTS(vp)) { ubc_pushdirty(vp); @@ -97,7 +97,7 @@ osi_VM_TryToSmush(struct vcache *avc, struct AFS_UCRED *acred, int sync) ReleaseWriteLock(&avc->lock); AFS_GUNLOCK(); #ifdef AFS_DARWIN80_ENV - ubc_sync_range(vp, 0, ubc_getsize(vp), UBC_INVALIDATE); + ubc_msync_range(vp, 0, ubc_getsize(vp), UBC_INVALIDATE); #else if (UBCINFOEXISTS(vp)) { size = ubc_getsize(vp); @@ -126,7 +126,7 @@ osi_VM_FlushPages(struct vcache *avc, struct AFS_UCRED *credp) off_t size; #ifdef AFS_DARWIN80_ENV size = ubc_getsize(vp); - ubc_sync_range(vp, 0, size, UBC_INVALIDATE); + ubc_msync_range(vp, 0, size, UBC_INVALIDATE); /* XXX what about when not CStatd */ if (avc->f.states & CStatd && size != avc->f.m.Length) ubc_setsize(vp, avc->f.m.Length); diff --git a/src/afs/DARWIN/osi_vnodeops.c b/src/afs/DARWIN/osi_vnodeops.c index 4dd4472..a2fd4e1 100644 --- a/src/afs/DARWIN/osi_vnodeops.c +++ b/src/afs/DARWIN/osi_vnodeops.c @@ -745,7 +745,7 @@ afs_vop_read(ap) if (vnode_isdir(ap->a_vp)) return EISDIR; #ifdef AFS_DARWIN80_ENV - ubc_sync_range(ap->a_vp, AFS_UIO_OFFSET(ap->a_uio), AFS_UIO_OFFSET(ap->a_uio) + AFS_UIO_RESID(ap->a_uio), UBC_PUSHDIRTY); + ubc_msync_range(ap->a_vp, AFS_UIO_OFFSET(ap->a_uio), AFS_UIO_OFFSET(ap->a_uio) + AFS_UIO_RESID(ap->a_uio), UBC_PUSHDIRTY); #else if (UBCINFOEXISTS(ap->a_vp)) { ubc_clean(ap->a_vp, 0); @@ -886,7 +886,7 @@ afs_vop_write(ap) struct vcache *avc = VTOAFS(ap->a_vp); void *object; #ifdef AFS_DARWIN80_ENV - ubc_sync_range(ap->a_vp, AFS_UIO_OFFSET(ap->a_uio), AFS_UIO_OFFSET(ap->a_uio) + AFS_UIO_RESID(ap->a_uio), UBC_INVALIDATE); + ubc_msync_range(ap->a_vp, AFS_UIO_OFFSET(ap->a_uio), AFS_UIO_OFFSET(ap->a_uio) + AFS_UIO_RESID(ap->a_uio), UBC_INVALIDATE); #else if (UBCINFOEXISTS(ap->a_vp)) { ubc_clean(ap->a_vp, 1); diff --git a/src/afs/FBSD/osi_machdep.h b/src/afs/FBSD/osi_machdep.h index bd305cf..95ec9d2 100644 --- a/src/afs/FBSD/osi_machdep.h +++ b/src/afs/FBSD/osi_machdep.h @@ -50,6 +50,9 @@ #undef gop_lookupname #define gop_lookupname osi_lookupname +#undef gop_lookupname_user +#define gop_lookupname osi_lookupname_user + #undef afs_suser #define afs_strcat(s1, s2) strcat((s1), (s2)) diff --git a/src/afs/HPUX/osi_machdep.h b/src/afs/HPUX/osi_machdep.h index 36d73d1..e8d1544 100644 --- a/src/afs/HPUX/osi_machdep.h +++ b/src/afs/HPUX/osi_machdep.h @@ -32,6 +32,8 @@ extern struct timeval time; vn_rdwr((rw),(gp),(base),(len),(offset),(segflg),(unit),(aresid),0) #define gop_lookupname(fnamep,segflg,followlink,compvpp) \ lookupname((fnamep),(segflg),(followlink),NULL,(compvpp)) +#define gop_lookupname_user(fnamep,segflg,followlink,compvpp) \ + lookupname((fnamep),(segflg),(followlink),NULL,(compvpp)) #undef afs_suser diff --git a/src/afs/IRIX/osi_machdep.h b/src/afs/IRIX/osi_machdep.h index 196a7ac..3cc7f79 100644 --- a/src/afs/IRIX/osi_machdep.h +++ b/src/afs/IRIX/osi_machdep.h @@ -32,6 +32,9 @@ extern time_t time; #undef gop_lookupname #define gop_lookupname(fnamep,segflg,followlink,compvpp) lookupname((fnamep),(segflg),(followlink),NULL,(compvpp), NULL) +#undef gop_lookupname_user +#define gop_lookupname_user(fnamep,segflg,followlink,compvpp) lookupname((fnamep),(segflg),(followlink),NULL,(compvpp), NULL) + #define osi_vnhold(avc, r) do { VN_HOLD(AFSTOV(avc)); } while(0) #undef afs_osi_Alloc_NoSleep diff --git a/src/afs/LINUX/osi_machdep.h b/src/afs/LINUX/osi_machdep.h index 7335c0b..0b2051a 100644 --- a/src/afs/LINUX/osi_machdep.h +++ b/src/afs/LINUX/osi_machdep.h @@ -103,6 +103,9 @@ static inline time_t osi_Time(void) { #undef gop_lookupname #define gop_lookupname osi_lookupname +#undef gop_lookupname_user +#define gop_lookupname_user osi_lookupname + #define osi_vnhold(V, N) do { VN_HOLD(AFSTOV(V)); } while (0) #define VN_HOLD(V) osi_Assert(igrab((V)) == (V)) #define VN_RELE(V) iput((V)) diff --git a/src/afs/LINUX/osi_misc.c b/src/afs/LINUX/osi_misc.c index a2c97fe..140cee4 100644 --- a/src/afs/LINUX/osi_misc.c +++ b/src/afs/LINUX/osi_misc.c @@ -112,9 +112,10 @@ osi_lookupname_internal(char *aname, int followlink, struct vfsmount **mnt, } return code; } + int osi_lookupname(char *aname, uio_seg_t seg, int followlink, - struct dentry **dpp) + struct dentry **dpp) { int code; char *tname; diff --git a/src/afs/NBSD/osi_machdep.h b/src/afs/NBSD/osi_machdep.h index f513d81..2ba9c45 100644 --- a/src/afs/NBSD/osi_machdep.h +++ b/src/afs/NBSD/osi_machdep.h @@ -39,6 +39,8 @@ extern struct timeval time; #undef gop_lookupname #define gop_lookupname(fnamep,segflg,followlink,compvpp) lookupname((fnamep),(segflg),(followlink),NULL,(compvpp)) +#undef gop_lookupname_user +#define gop_lookupname_user(fnamep,segflg,followlink,compvpp) lookupname((fnamep),(segflg),(followlink),NULL,(compvpp)) #define osi_vnhold(avc,r) do { \ if ((avc)->vrefCount) { VN_HOLD((struct vnode *)(avc)); } \ diff --git a/src/afs/OBSD/osi_machdep.h b/src/afs/OBSD/osi_machdep.h index 933f03c..b17d03b 100644 --- a/src/afs/OBSD/osi_machdep.h +++ b/src/afs/OBSD/osi_machdep.h @@ -132,6 +132,10 @@ extern int afs_vget(); #define gop_lookupname(fnamep, segflg, followlink, compvpp) \ afs_nbsd_lookupname((fnamep), (segflg), (followlink), (compvpp)) +#undef gop_lookupname_user +#define gop_lookupname_user(fnamep, segflg, followlink, compvpp) \ + afs_nbsd_lookupname((fnamep), (segflg), (followlink), (compvpp)) + #ifdef AFS_OBSD39_ENV #define afs_osi_lockmgr(l, f, i, p) lockmgr((l), (f), (i)) #else diff --git a/src/afs/SOLARIS/osi_machdep.h b/src/afs/SOLARIS/osi_machdep.h index 373fe34..e750732 100644 --- a/src/afs/SOLARIS/osi_machdep.h +++ b/src/afs/SOLARIS/osi_machdep.h @@ -61,6 +61,8 @@ extern void *afs_osi_Alloc_NoSleep(size_t size); vn_rdwr((rw),(gp),(base),(len),(offset),(segflg),(ioflag),(ulimit),(cr),(aresid)) #define gop_lookupname(fnamep,segflg,followlink,compvpp) \ lookupname((fnamep),(segflg),(followlink),NULL,(compvpp)) +#define gop_lookupname_user(fnamep,segflg,followlink,compvpp) \ + lookupname((fnamep),(segflg),(followlink),NULL,(compvpp)) #if defined(AFS_SUN510_ENV) diff --git a/src/afs/UKERNEL/osi_machdep.h b/src/afs/UKERNEL/osi_machdep.h index 5560efd..7abe453 100644 --- a/src/afs/UKERNEL/osi_machdep.h +++ b/src/afs/UKERNEL/osi_machdep.h @@ -38,6 +38,8 @@ #undef gop_lookupname #define gop_lookupname(fnamep,segflg,followlink,compvpp) lookupname((fnamep),(segflg),(followlink),(compvpp)) +#undef gop_lookupname_user +#define gop_lookupname_user(fnamep,segflg,followlink,compvpp) lookupname((fnamep),(segflg),(followlink),(compvpp)) #define osi_vnhold(avc, r) do { VN_HOLD(AFSTOV(avc)); } while(0) diff --git a/src/afs/afs.h b/src/afs/afs.h index fe91b18..20bde01 100644 --- a/src/afs/afs.h +++ b/src/afs/afs.h @@ -982,9 +982,15 @@ struct cm_initparams { #define IFAnyPages 32 #define IFDiscarded 64 /* index entry in discardDCList */ +#ifdef AFS_DARWIN100_ENV +typedef user_addr_t iparmtype; /* 64 bit */ +#else +typedef char * iparmtype; +#endif + struct afs_ioctl { - char *in; /* input buffer */ - char *out; /* output buffer */ + iparmtype in; /* input buffer */ + iparmtype out; /* output buffer */ short in_size; /* Size of input buffer <= 2K */ short out_size; /* Maximum size of output buffer, <= 2K */ }; diff --git a/src/afs/afs_call.c b/src/afs/afs_call.c index 058120a..5c025c4 100644 --- a/src/afs/afs_call.c +++ b/src/afs/afs_call.c @@ -476,8 +476,30 @@ wait_for_cachedefs(void) { #endif } +#ifdef AFS_DARWIN100_ENV +#define AFSKPTR(X) k ## X int -afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long parm6) +afs_syscall_call(long parm, long parm2, long parm3, + long parm4, long parm5, long parm6) +{ + return afs_syscall64_call(CAST_USER_ADDR_T((parm)), + CAST_USER_ADDR_T((parm2)), + CAST_USER_ADDR_T((parm3)), + CAST_USER_ADDR_T((parm4)), + CAST_USER_ADDR_T((parm5)), + CAST_USER_ADDR_T((parm6))); +} +#else +#define AFSKPTR(X) ((caddr_t)X) +#endif +int +#ifdef AFS_DARWIN100_ENV +afs_syscall64_call(user_addr_t kparm, user_addr_t kparm2, user_addr_t kparm3, + user_addr_t kparm4, user_addr_t kparm5, user_addr_t kparm6) +#else +afs_syscall_call(long parm, long parm2, long parm3, + long parm4, long parm5, long parm6) +#endif { afs_int32 code = 0; #if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) @@ -485,6 +507,15 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long #else /* AFS_SGI61_ENV */ u_int bufferSize; #endif /* AFS_SGI61_ENV */ +#ifdef AFS_DARWIN100_ENV + /* AFSKPTR macro relies on this name format/mapping */ + afs_uint32 parm = (afs_uint32)kparm; + afs_uint32 parm2 = (afs_uint32)kparm2; + afs_uint32 parm3 = (afs_uint32)kparm3; + afs_uint32 parm4 = (afs_uint32)kparm4; + afs_uint32 parm5 = (afs_uint32)kparm5; + afs_uint32 parm6 = (afs_uint32)kparm6; +#endif AFS_STATCNT(afs_syscall_call); if ( @@ -683,14 +714,14 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long code = afs_InitDynroot(); if (!code) { - AFS_COPYIN((char *)parm2, (char *)tcell->hosts, sizeof(tcell->hosts), + AFS_COPYIN(AFSKPTR(parm2), (caddr_t)tcell->hosts, sizeof(tcell->hosts), code); } if (!code) { if (parm4 > sizeof(tcell->cellName)) code = EFAULT; else { - AFS_COPYIN((char *)parm3, tcell->cellName, parm4, code); + AFS_COPYIN(AFSKPTR(parm3), (caddr_t)tcell->cellName, parm4, code); if (!code) afs_NewCell(tcell->cellName, tcell->hosts, parm5, NULL, 0, 0, 0); @@ -711,15 +742,15 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long afs_osi_Sleep(&afs_initState); #endif - AFS_COPYIN((char *)parm2, (char *)tcell->hosts, sizeof(tcell->hosts), + AFS_COPYIN(AFSKPTR(parm2), (caddr_t)tcell->hosts, sizeof(tcell->hosts), code); } if (!code) { - AFS_COPYINSTR((char *)parm3, tbuffer1, AFS_SMALLOCSIZ, + AFS_COPYINSTR(AFSKPTR(parm3), tbuffer1, AFS_SMALLOCSIZ, &bufferSize, code); if (!code) { if (parm4 & 4) { - AFS_COPYINSTR((char *)parm5, tbuffer, AFS_SMALLOCSIZ, + AFS_COPYINSTR(AFSKPTR(parm5), tbuffer, AFS_SMALLOCSIZ, &bufferSize, code); if (!code) { lcnamep = tbuffer; @@ -746,11 +777,11 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long code = afs_InitDynroot(); if (!code) { - AFS_COPYINSTR((char *)parm2, aliasName, AFS_SMALLOCSIZ, &bufferSize, + AFS_COPYINSTR(AFSKPTR(parm2), aliasName, AFS_SMALLOCSIZ, &bufferSize, code); } if (!code) - AFS_COPYINSTR((char *)parm3, cellName, AFS_SMALLOCSIZ, + AFS_COPYINSTR(AFSKPTR(parm3), cellName, AFS_SMALLOCSIZ, &bufferSize, code); if (!code) afs_NewCellAlias(aliasName, cellName); @@ -765,7 +796,7 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long code = afs_InitDynroot(); if (!code) { - AFS_COPYINSTR((char *)parm2, cell, AFS_SMALLOCSIZ, &bufferSize, code); + AFS_COPYINSTR(AFSKPTR(parm2), cell, AFS_SMALLOCSIZ, &bufferSize, code); } if (!code) afs_SetPrimaryCell(cell); @@ -776,7 +807,7 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long if (afs_CacheInit_Done) goto out; - AFS_COPYIN((char *)parm2, (caddr_t) & cparms, sizeof(cparms), code); + AFS_COPYIN(AFSKPTR(parm2), (caddr_t) & cparms, sizeof(cparms), code); if (code) { #if defined(KERNEL_HAVE_UERROR) setuerror(code); @@ -824,7 +855,7 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long afs_osi_Sleep(&afs_initState); if (parm2) { - AFS_COPYINSTR((char *)parm2, afs_rootVolumeName, + AFS_COPYINSTR(AFSKPTR(parm2), afs_rootVolumeName, sizeof(afs_rootVolumeName), &bufferSize, code); afs_rootVolumeName[sizeof(afs_rootVolumeName) - 1] = 0; } else @@ -835,7 +866,7 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ); code = 0; - AFS_COPYINSTR((char *)parm2, tbuffer, AFS_SMALLOCSIZ, &bufferSize, + AFS_COPYINSTR(AFSKPTR(parm2), tbuffer, AFS_SMALLOCSIZ, &bufferSize, code); if (code) { osi_FreeSmallSpace(tbuffer); @@ -845,7 +876,7 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long tbuffer[AFS_SMALLOCSIZ - 1] = '\0'; /* null-terminate the name */ /* We have the cache dir copied in. Call the cache init routine */ #ifdef AFS_DARWIN80_ENV - get_vfs_context(); + get_vfs_context(); #endif if (parm == AFSOP_CACHEBASEDIR) { strncpy(afs_cachebasedir, tbuffer, 1024); @@ -950,39 +981,43 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long count = AFS_MAX_INTERFACE_ADDR; } - AFS_COPYIN((char *)parm3, (char *)buffer, count * sizeof(afs_int32), + AFS_COPYIN(AFSKPTR(parm3), (caddr_t)buffer, count * sizeof(afs_int32), code); - if (parm4) - AFS_COPYIN((char *)parm4, (char *)maskbuffer, + if (parm4 && !code) + AFS_COPYIN(AFSKPTR(parm4), (caddr_t)maskbuffer, count * sizeof(afs_int32), code); - if (parm5) - AFS_COPYIN((char *)parm5, (char *)mtubuffer, + if (parm5 && !code) + AFS_COPYIN(AFSKPTR(parm5), (caddr_t)mtubuffer, count * sizeof(afs_int32), code); - afs_cb_interface.numberOfInterfaces = count; - for (i = 0; i < count; i++) { - afs_cb_interface.addr_in[i] = buffer[i]; + if (!code) { + afs_cb_interface.numberOfInterfaces = count; + for (i = 0; i < count; i++) { + afs_cb_interface.addr_in[i] = buffer[i]; #ifdef AFS_USERSPACE_IP_ADDR - /* AFS_USERSPACE_IP_ADDR means we have no way of finding the - * machines IP addresses when in the kernel (the in_ifaddr - * struct is not available), so we pass the info in at - * startup. We also pass in the subnetmask and mtu size. The - * subnetmask is used when setting the rank: - * afsi_SetServerIPRank(); and the mtu size is used when - * finding the best mtu size. rxi_FindIfnet() is replaced - * with rxi_Findcbi(). - */ - afs_cb_interface.subnetmask[i] = - (parm4 ? maskbuffer[i] : 0xffffffff); - afs_cb_interface.mtu[i] = (parm5 ? mtubuffer[i] : htonl(1500)); + /* AFS_USERSPACE_IP_ADDR means we have no way of finding the + * machines IP addresses when in the kernel (the in_ifaddr + * struct is not available), so we pass the info in at + * startup. We also pass in the subnetmask and mtu size. The + * subnetmask is used when setting the rank: + * afsi_SetServerIPRank(); and the mtu size is used when + * finding the best mtu size. rxi_FindIfnet() is replaced + * with rxi_Findcbi(). + */ + afs_cb_interface.subnetmask[i] = + (parm4 ? maskbuffer[i] : 0xffffffff); + afs_cb_interface.mtu[i] = (parm5 ? mtubuffer[i] : htonl(1500)); #endif - } - rxi_setaddr(buffer[0]); - if (!refresh) { - if (rxbind) - rx_bindhost = buffer[0]; - else - rx_bindhost = htonl(INADDR_ANY); + } + rxi_setaddr(buffer[0]); + if (!refresh) { + if (rxbind) + rx_bindhost = buffer[0]; + else + rx_bindhost = htonl(INADDR_ANY); + } + } else { + refresh = 0; } afs_osi_Free(buffer, sizeof(afs_int32) * AFS_MAX_INTERFACE_ADDR); @@ -1058,8 +1093,8 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long #endif /* else AFS_USERSPACE_IP_ADDR */ #endif /* !AFS_SUN5_ENV */ if (!code) - AFS_COPYOUT((caddr_t) & mtu, (caddr_t) parm3, sizeof(afs_int32), - code); + AFS_COPYOUT((caddr_t) & mtu, AFSKPTR(parm3), + sizeof(afs_int32), code); #ifdef AFS_AIX32_ENV /* this is disabled for now because I can't figure out how to get access * to these kernel variables. It's only for supporting user-mode rx @@ -1096,8 +1131,8 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long #endif /* else AFS_USERSPACE_IP_ADDR */ #endif /* !AFS_SUN5_ENV */ if (!code) - AFS_COPYOUT((caddr_t) & mask, (caddr_t) parm3, sizeof(afs_int32), - code); + AFS_COPYOUT((caddr_t) & mask, AFSKPTR(parm3), + sizeof(afs_int32), code); } #ifdef AFS_AFSDB_ENV else if (parm == AFSOP_AFSDB_HANDLER) { @@ -1110,8 +1145,8 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long #ifndef UKERNEL afs_osi_MaskUserLoop(); #endif - AFS_COPYIN((afs_int32 *) parm2, cellname, cellLen, code); - AFS_COPYIN((afs_int32 *) parm3, kmsg, kmsgLen, code); + AFS_COPYIN(AFSKPTR(parm2), cellname, cellLen, code); + AFS_COPYIN(AFSKPTR(parm3), kmsg, kmsgLen, code); if (!code) { code = afs_AFSDBHandler(cellname, cellLen, kmsg); if (*cellname == 1) @@ -1122,7 +1157,7 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long } } if (!code) - AFS_COPYOUT(cellname, (char *)parm2, cellLen, code); + AFS_COPYOUT(cellname, AFSKPTR(parm2), cellLen, code); afs_osi_Free(kmsg, kmsgLen); afs_osi_Free(cellname, cellLen); } @@ -1138,9 +1173,10 @@ afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long rx_extraPackets = parm2; afscall_set_rxpck_received = 1; } else if (parm == AFSOP_SET_RXMAXMTU) { - rx_MyMaxSendSize = rx_maxReceiveSizeUser = rx_maxReceiveSize = parm2; - } else + rx_MyMaxSendSize = rx_maxReceiveSizeUser = rx_maxReceiveSize = parm2; + } else { code = EINVAL; + } out: AFS_GUNLOCK(); diff --git a/src/afs/afs_icl.c b/src/afs/afs_icl.c index 17e3398..54ce04e 100644 --- a/src/afs/afs_icl.c +++ b/src/afs/afs_icl.c @@ -81,9 +81,29 @@ struct afs_icl_log *afs_icl_FindLog(char *); struct afs_icl_set *afs_icl_FindSet(char *); +#ifdef AFS_DARWIN100_ENV +#define AFSKPTR(X) k ## X int Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval) { + return Afscall64_icl(opcode, + CAST_USER_ADDR_T((p1)), + CAST_USER_ADDR_T((p2)), + CAST_USER_ADDR_T((p3)), + CAST_USER_ADDR_T((p4)), + retval); +} +#else +#define AFSKPTR(X) ((caddr_t)X) +#endif + +int +#ifdef AFS_DARWIN100_ENV +Afscall64_icl(int opcode, user_addr_t kp1, user_addr_t kp2, user_addr_t kp3, user_addr_t kp4, int *retval) +#else +Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval) +#endif +{ afs_int32 *lp, elts, flags; register afs_int32 code; struct afs_icl_log *logp; @@ -101,6 +121,12 @@ Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval) afs_int32 startCookie; afs_int32 allocated; struct afs_icl_log *tlp; +#ifdef AFS_DARWIN100_ENV + afs_uint32 p1 = (afs_uint32)kp1; + afs_uint32 p2 = (afs_uint32)kp2; + afs_uint32 p3 = (afs_uint32)kp3; + afs_uint32 p4 = (afs_uint32)kp4; +#endif #ifdef AFS_SUN5_ENV if (!afs_suser(CRED())) { /* only root can run this code */ @@ -124,12 +150,13 @@ Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval) * updates cookie to updated start (not end) if we had to * skip some records. */ - AFS_COPYINSTR((char *)p1, tname, sizeof(tname), &temp, code); + AFS_COPYINSTR(AFSKPTR(p1), tname, sizeof(tname), &temp, code); if (code) return code; - AFS_COPYIN((char *)p4, (char *)&startCookie, sizeof(afs_int32), code); + AFS_COPYIN(AFSKPTR(p4), (char *)&startCookie, sizeof(afs_int32), code); if (code) return code; + afs_warn("looking for log %s\n", tname); logp = afs_icl_FindLog(tname); if (!logp) return ENOENT; @@ -146,10 +173,10 @@ Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval) osi_FreeLargeSpace((struct osi_buffer *)lp); break; } - AFS_COPYOUT((char *)lp, (char *)p2, elts * sizeof(afs_int32), code); + AFS_COPYOUT((char *)lp, AFSKPTR(p2), elts * sizeof(afs_int32), code); if (code) goto done; - AFS_COPYOUT((char *)&startCookie, (char *)p4, sizeof(afs_int32), + AFS_COPYOUT((char *)&startCookie, AFSKPTR(p4), sizeof(afs_int32), code); if (code) goto done; @@ -177,9 +204,9 @@ Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval) temp = strlen(tlp->name) + 1; if (temp > p3) return EINVAL; - AFS_COPYOUT(tlp->name, (char *)p2, temp, code); + AFS_COPYOUT(tlp->name, AFSKPTR(p2), temp, code); if (!code) /* copy out size of log */ - AFS_COPYOUT((char *)&tlp->logSize, (char *)p4, sizeof(afs_int32), + AFS_COPYOUT((char *)&tlp->logSize, AFSKPTR(p4), sizeof(afs_int32), code); break; @@ -187,7 +214,7 @@ Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval) /* enumerate logs: p1=setname, p2=index, p3=&name, p4=sizeof(name). * return 0 for success, otherwise error. */ - AFS_COPYINSTR((char *)p1, tname, sizeof(tname), &temp, code); + AFS_COPYINSTR(AFSKPTR(p1), tname, sizeof(tname), &temp, code); if (code) return code; setp = afs_icl_FindSet(tname); diff --git a/src/afs/afs_osi.h b/src/afs/afs_osi.h index cc4f1d2..de0462c 100644 --- a/src/afs/afs_osi.h +++ b/src/afs/afs_osi.h @@ -279,7 +279,7 @@ typedef struct timeval osi_timeval_t; * and kernel space. Call these to avoid taking page faults while * holding the global lock. */ -#if defined(CAST_USER_ADDR_T) && !defined(UKERNEL) +#if defined(CAST_USER_ADDR_T) && !defined(UKERNEL) && !defined(AFS_DARWIN100_ENV) #define __U(X) CAST_USER_ADDR_T((X)) #else #define __U(X) (X) @@ -291,7 +291,7 @@ typedef struct timeval osi_timeval_t; int haveGlock = ISAFS_GLOCK(); \ if (haveGlock) \ AFS_GUNLOCK(); \ - CODE = copyin(__U((SRC)),(DST),(LEN)); \ + CODE = copyin(__U((SRC)),(DST),(LEN)); \ if (haveGlock) \ AFS_GLOCK(); \ } while(0) diff --git a/src/afs/afs_osi_pag.c b/src/afs/afs_osi_pag.c index 3bc4723..cfb8b28 100644 --- a/src/afs/afs_osi_pag.c +++ b/src/afs/afs_osi_pag.c @@ -254,13 +254,13 @@ afs_setpag(void) } #elif defined(AFS_DARWIN80_ENV) { - struct ucred *credp = kauth_cred_proc_ref(p); + struct AFS_UCRED *credp = kauth_cred_proc_ref(p); code = AddPag(p, genpag(), &credp); - kauth_cred_rele(credp); + crfree(credp); } #elif defined(AFS_DARWIN_ENV) { - struct ucred *credp = crdup(p->p_cred->pc_ucred); + struct AFS_UCRED *credp = crdup(p->p_cred->pc_ucred); code = AddPag(p, genpag(), &credp); crfree(credp); } diff --git a/src/afs/afs_pioctl.c b/src/afs/afs_pioctl.c index 2ca6d09..2914ce7 100644 --- a/src/afs/afs_pioctl.c +++ b/src/afs/afs_pioctl.c @@ -142,7 +142,7 @@ int HandleIoctl(register struct vcache *avc, register afs_int32 acom, int afs_HandlePioctl(struct vnode *avp, afs_int32 acom, register struct afs_ioctl *ablob, int afollow, struct AFS_UCRED **acred); -static int Prefetch(char *apath, struct afs_ioctl *adata, int afollow, +static int Prefetch(iparmtype apath, struct afs_ioctl *adata, int afollow, struct AFS_UCRED *acred); typedef int (*pioctlFunction) (struct vcache *, int, struct vrequest *, @@ -315,7 +315,6 @@ HandleIoctl(register struct vcache *avc, register afs_int32 acom, return code; /* so far, none implemented */ } - #ifdef AFS_AIX_ENV /* For aix we don't temporarily bypass ioctl(2) but rather do our * thing directly in the vnode layer call, VNOP_IOCTL; thus afs_ioctl @@ -779,7 +778,10 @@ int afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow, rval_t *vvp, struct AFS_UCRED *credp) #else -#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) +#ifdef AFS_DARWIN100_ENV +afs_syscall64_pioctl(user_addr_t path, unsigned int com, user_addr_t cmarg, + int follow, struct AFS_UCRED *credp) +#elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow, struct AFS_UCRED *credp) #else @@ -889,11 +891,11 @@ afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow) foreigncreds ? foreigncreds : credp); #else #ifdef AFS_LINUX22_ENV - code = gop_lookupname(path, AFS_UIOUSER, follow, &dp); + code = gop_lookupname_user(path, AFS_UIOUSER, follow, &dp); if (!code) vp = (struct vnode *)dp->d_inode; #else - code = gop_lookupname(path, AFS_UIOUSER, follow, &vp); + code = gop_lookupname_user(path, AFS_UIOUSER, follow, &vp); #endif /* AFS_LINUX22_ENV */ #endif /* AFS_AIX41_ENV */ AFS_GLOCK(); @@ -1004,6 +1006,17 @@ afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow) #endif } +#ifdef AFS_DARWIN100_ENV +int +afs_syscall_pioctl(char * path, unsigned int com, caddr_t cmarg, + int follow, struct AFS_UCRED *credp) +{ + return afs_syscall64_pioctl(CAST_USER_ADDR_T(path), com, + CAST_USER_ADDR_T((unsigned int)cmarg), follow, + credp); +} +#endif + #define MAXPIOCTLTOKENLEN \ (3*sizeof(afs_int32)+MAXKTCTICKETLEN+sizeof(struct ClearToken)+MAXKTCREALMLEN) @@ -2276,7 +2289,7 @@ DECL_PIOCTL(PCheckAuth) } static int -Prefetch(char *apath, struct afs_ioctl *adata, int afollow, +Prefetch(iparmtype apath, struct afs_ioctl *adata, int afollow, struct AFS_UCRED *acred) { register char *tp; diff --git a/src/afs/afs_prototypes.h b/src/afs/afs_prototypes.h index 7c3b31f..a6ff4dd 100644 --- a/src/afs/afs_prototypes.h +++ b/src/afs/afs_prototypes.h @@ -45,6 +45,11 @@ extern void shutdown_afstest(void); extern void afs_shutdown_BKG(void); extern int afs_syscall_call(long parm, long parm2, long parm3, long parm4, long parm5, long parm6); +#if defined(AFS_DARWIN100_ENV) +extern int afs_syscall64_call(user_addr_t parm, user_addr_t parm2, + user_addr_t parm3, user_addr_t parm4, + user_addr_t parm5, user_addr_t parm6); +#endif /* afs_callback.c */ @@ -405,7 +410,10 @@ extern void afs_icl_AppendRecord(register struct afs_icl_log *logp, long p2, long p3, long p4); extern int Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval); - +#ifdef AFS_DARWIN100_ENV +extern int Afscall64_icl(int opcode, user_addr_t p1, user_addr_t p2, + user_addr_t p3, user_addr_t p4, int *retval); +#endif /* afs_init.c */ extern struct cm_initparams cm_initParams; @@ -779,6 +787,11 @@ extern afs_int32 afs_waitForever; extern short afs_waitForeverCount; extern afs_int32 afs_showflags; extern int afs_defaultAsynchrony; +#if defined(AFS_DARWIN100_ENV) +extern int afs_syscall64_pioctl(user_addr_t path, unsigned int com, + user_addr_t cmarg, int follow, \ + struct AFS_UCRED *credp); +#endif #ifdef AFS_SUN5_ENV extern int afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow, rval_t *rvp, struct AFS_UCRED *credp); @@ -873,7 +886,11 @@ extern void afs_AddToMean(struct afs_MeanStats *oldMean, afs_int32 newValue); #endif /* afs_syscall.c */ +#ifdef AFS_DARWIN100_ENV +extern int copyin_afs_ioctl(user_addr_t cmarg, struct afs_ioctl *dst); +#else extern int copyin_afs_ioctl(caddr_t cmarg, struct afs_ioctl *dst); +#endif #ifdef UKERNEL extern int Afs_syscall(void); #endif diff --git a/src/afs/afs_syscall.c b/src/afs/afs_syscall.c index c14c84e..e4db706 100644 --- a/src/afs/afs_syscall.c +++ b/src/afs/afs_syscall.c @@ -45,7 +45,11 @@ afs_ioctl32_to_afs_ioctl(const struct afs_ioctl32 *src, struct afs_ioctl *dst) */ int +#ifdef AFS_DARWIN100_ENV +copyin_afs_ioctl(user_addr_t cmarg, struct afs_ioctl *dst) +#else copyin_afs_ioctl(caddr_t cmarg, struct afs_ioctl *dst) +#endif { int code; #if defined(AFS_DARWIN100_ENV) @@ -318,10 +322,10 @@ Afs_syscall(struct afsargs *uap, rval_t * rvp) #else /* AFS_SGI_ENV */ struct iparam { - long param1; - long param2; - long param3; - long param4; + iparmtype param1; + iparmtype param2; + iparmtype param3; + iparmtype param4; }; struct iparam32 { @@ -346,6 +350,9 @@ iparam32_to_iparam(const struct iparam32 *src, struct iparam *dst) /* * If you need to change copyin_iparam(), you may also need to change * copyin_afs_ioctl(). + * + * This function is needed only for icreate, meaning, only on platforms + * providing the inode fileserver. */ static int @@ -353,16 +360,6 @@ copyin_iparam(caddr_t cmarg, struct iparam *dst) { int code; -#if defined(AFS_DARWIN100_ENV) - struct iparam32 dst32; - - if (!proc_is64bit(current_proc())) { - AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code); - if (!code) - iparam32_to_iparam(&dst32, dst); - return code; - } -#endif #if defined(AFS_HPUX_64BIT_ENV) struct iparam32 dst32; @@ -464,7 +461,31 @@ Afs_syscall(register struct afssysa *uap, rval_t * rvp) { int *retval = &rvp->r_val1; #else /* AFS_SUN5_ENV */ -#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) +#ifdef AFS_DARWIN100_ENV +struct afssysa { + afs_int32 syscall; + afs_int32 parm1; + afs_int32 parm2; + afs_int32 parm3; + afs_int32 parm4; + afs_int32 parm5; + afs_int32 parm6; +}; +struct afssysa64 { + afs_int64 parm1; + afs_int64 parm2; + afs_int64 parm3; + afs_int64 parm4; + afs_int64 parm5; + afs_int64 parm6; + afs_int32 syscall; +}; +int +afs3_syscall(struct proc *p, void *args, unsigned int *retval) +{ + struct afssysa64 *uap64 = NULL; + struct afssysa *uap = NULL; +#elif defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) int afs3_syscall(p, args, retval) #ifdef AFS_FBSD50_ENV @@ -599,6 +620,37 @@ Afs_syscall() #if defined(AFS_DARWIN80_ENV) get_vfs_context(); osi_Assert(*retval == 0); +#ifdef AFS_DARWIN100_ENV + if (proc_is64bit(p)) { + uap64 = (struct afssysa64 *)args; + if (uap64->syscall == AFSCALL_CALL) { + code = + afs_syscall64_call(uap64->parm1, uap64->parm2, uap64->parm3, + uap64->parm4, uap64->parm5, uap64->parm6); + } else if (uap64->syscall == AFSCALL_SETPAG) { + AFS_GLOCK(); + code = afs_setpag(p, args, retval); + AFS_GUNLOCK(); + } else if (uap64->syscall == AFSCALL_PIOCTL) { + AFS_GLOCK(); + code = + afs_syscall64_pioctl(uap64->parm1, (unsigned int)uap64->parm2, + uap64->parm3, (int)uap64->parm4, + kauth_cred_get()); + AFS_GUNLOCK(); + } else if (uap64->syscall == AFSCALL_ICL) { + AFS_GLOCK(); + code = + Afscall64_icl(uap64->parm1, uap64->parm2, uap64->parm3, + uap64->parm4, uap64->parm5, retval); + AFS_GUNLOCK(); + } else + code = EINVAL; + if (uap64->syscall != AFSCALL_CALL) + put_vfs_context(); + } else { /* and the default case for 32 bit procs */ +#endif + uap = (struct afssysa *)args; #endif #if defined(AFS_HPUX_ENV) /* @@ -607,134 +659,137 @@ Afs_syscall() * duplication to handle the case of a dynamically loaded kernel * module? */ - osi_InitGlock(); + osi_InitGlock(); #endif - if (uap->syscall == AFSCALL_CALL) { - code = - afs_syscall_call(uap->parm1, uap->parm2, uap->parm3, uap->parm4, - uap->parm5, uap->parm6); - } else if (uap->syscall == AFSCALL_SETPAG) { + if (uap->syscall == AFSCALL_CALL) { + code = + afs_syscall_call(uap->parm1, uap->parm2, uap->parm3, + uap->parm4, uap->parm5, uap->parm6); + } else if (uap->syscall == AFSCALL_SETPAG) { #ifdef AFS_SUN5_ENV - register proc_t *procp; + register proc_t *procp; - procp = ttoproc(curthread); - AFS_GLOCK(); - code = afs_setpag(&procp->p_cred); - AFS_GUNLOCK(); + procp = ttoproc(curthread); + AFS_GLOCK(); + code = afs_setpag(&procp->p_cred); + AFS_GUNLOCK(); #else - AFS_GLOCK(); + AFS_GLOCK(); #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) - code = afs_setpag(p, args, retval); + code = afs_setpag(p, args, retval); #else /* AFS_OSF_ENV */ - code = afs_setpag(); + code = afs_setpag(); #endif - AFS_GUNLOCK(); + AFS_GUNLOCK(); #endif - } else if (uap->syscall == AFSCALL_PIOCTL) { - AFS_GLOCK(); + } else if (uap->syscall == AFSCALL_PIOCTL) { + AFS_GLOCK(); #if defined(AFS_SUN5_ENV) - code = - afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, uap->parm4, - rvp, CRED()); + code = + afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, + uap->parm4, rvp, CRED()); #elif defined(AFS_FBSD50_ENV) - code = - afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, uap->parm4, - p->td_ucred); + code = + afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, + uap->parm4, p->td_ucred); #elif defined(AFS_DARWIN80_ENV) - code = - afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, uap->parm4, - kauth_cred_get()); + code = + afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, + uap->parm4, kauth_cred_get()); #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) - code = - afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, uap->parm4, - p->p_cred->pc_ucred); + code = + afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3, + uap->parm4, p->p_cred->pc_ucred); #else - code = - afs_syscall_pioctl((char *)uap->parm1, (unsigned int)uap->parm2, (caddr_t)uap->parm3, - (int) uap->parm4); + code = + afs_syscall_pioctl((char *)uap->parm1, + (unsigned int)uap->parm2, + (caddr_t)uap->parm3, + (int) uap->parm4); #endif - AFS_GUNLOCK(); - } else if (uap->syscall == AFSCALL_ICREATE) { - struct iparam iparams; + AFS_GUNLOCK(); + } else if (uap->syscall == AFSCALL_ICREATE) { + struct iparam iparams; - code = copyin_iparam((char *)uap->parm3, &iparams); - if (code) { + code = copyin_iparam((char *)uap->parm3, &iparams); + if (code) { #if defined(KERNEL_HAVE_UERROR) - setuerror(code); + setuerror(code); #endif - } else + } else { #ifdef AFS_SUN5_ENV - code = - afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1, - iparams.param2, iparams.param3, - iparams.param4, rvp, CRED()); + code = + afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1, + iparams.param2, iparams.param3, + iparams.param4, rvp, CRED()); #else - code = - afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1, - iparams.param2, + code = + afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1, + iparams.param2, iparams.param3, + iparams.param4 #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) - iparams.param3, iparams.param4, retval); -#else - iparams.param3, iparams.param4); + , retval #endif + ); #endif /* AFS_SUN5_ENV */ - } else if (uap->syscall == AFSCALL_IOPEN) { + } + } else if (uap->syscall == AFSCALL_IOPEN) { #ifdef AFS_SUN5_ENV - code = - afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3, rvp, - CRED()); + code = + afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3, rvp, + CRED()); #else + code = afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3 #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) - code = afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3, retval); -#else - code = afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3); + , retval #endif + ); #endif /* AFS_SUN5_ENV */ - } else if (uap->syscall == AFSCALL_IDEC) { + } else if (uap->syscall == AFSCALL_IDEC) { + code = + afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, -1 #ifdef AFS_SUN5_ENV - code = - afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, -1, rvp, - CRED()); -#else - code = afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, -1); -#endif /* AFS_SUN5_ENV */ - } else if (uap->syscall == AFSCALL_IINC) { + , rvp, CRED() +#endif + ); + } else if (uap->syscall == AFSCALL_IINC) { + code = + afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, 1 #ifdef AFS_SUN5_ENV - code = - afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, 1, rvp, - CRED()); -#else - code = afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, 1); -#endif /* AFS_SUN5_ENV */ - } else if (uap->syscall == AFSCALL_ICL) { - AFS_GLOCK(); - code = - Afscall_icl(uap->parm1, uap->parm2, uap->parm3, uap->parm4, - uap->parm5, retval); - AFS_GUNLOCK(); + , rvp, CRED() +#endif + ); + } else if (uap->syscall == AFSCALL_ICL) { + AFS_GLOCK(); + code = + Afscall_icl(uap->parm1, uap->parm2, uap->parm3, uap->parm4, + uap->parm5, retval); + AFS_GUNLOCK(); #ifdef AFS_LINUX20_ENV - if (!code) { - /* ICL commands can return values. */ - code = -linux_ret; /* Gets negated again at exit below */ - } + if (!code) { + /* ICL commands can return values. */ + code = -linux_ret; /* Gets negated again at exit below */ + } #else - if (code) { + if (code) { #if defined(KERNEL_HAVE_UERROR) - setuerror(code); + setuerror(code); #endif - } + } #endif /* !AFS_LINUX20_ENV */ - } else { + } else { #if defined(KERNEL_HAVE_UERROR) - setuerror(EINVAL); + setuerror(EINVAL); #else - code = EINVAL; + code = EINVAL; #endif - } - + } #if defined(AFS_DARWIN80_ENV) - if (uap->syscall != AFSCALL_CALL) - put_vfs_context(); + if (uap->syscall != AFSCALL_CALL) + put_vfs_context(); +#ifdef AFS_DARWIN100_ENV + } /* 32 bit procs */ +#endif #endif #ifdef AFS_LINUX20_ENV code = -code; @@ -743,4 +798,4 @@ Afs_syscall() return code; } #endif /* AFS_SGI_ENV */ -#endif /* !AFS_AIX32_ENV */ +#endif /* !AFS_AIX32_ENV */ diff --git a/src/afs/afs_vcache.c b/src/afs/afs_vcache.c index a3285ff..f94472e 100644 --- a/src/afs/afs_vcache.c +++ b/src/afs/afs_vcache.c @@ -1264,7 +1264,7 @@ afs_FlushActiveVcaches(register afs_int32 doflocks) register int i; register struct afs_conn *tc; register afs_int32 code; - register struct AFS_UCRED *cred = NULL; + struct AFS_UCRED *cred = NULL; struct vrequest treq, ureq; struct AFSVolSync tsync; int didCore; diff --git a/src/afsd/afsd.c b/src/afsd/afsd.c index 40afb63..20d6309 100644 --- a/src/afsd/afsd.c +++ b/src/afsd/afsd.c @@ -2614,10 +2614,9 @@ HandleMTab(void) } #if !defined(AFS_SGI_ENV) && !defined(AFS_AIX32_ENV) - int call_syscall(long param1, long param2, long param3, long param4, long param5, - long param6, long param7) + long param6, long param7) { int error; #ifdef AFS_LINUX20_ENV @@ -2645,22 +2644,50 @@ call_syscall(long param1, long param2, long param3, long param4, long param5, #endif #ifdef AFS_DARWIN80_ENV struct afssysargs syscall_data; + void *ioctldata; int fd = open(SYSCALL_DEV_FNAME,O_RDWR); - syscall_data.syscall = AFSCALL_CALL; - syscall_data.param1 = param1; - syscall_data.param2 = param2; - syscall_data.param3 = param3; - syscall_data.param4 = param4; - syscall_data.param5 = param5; - syscall_data.param6 = param6; + int syscallnum, is64 = 0; +#ifdef AFS_DARWIN100_ENV + struct afssysargs64 syscall64_data; + if (sizeof(param1) == 8) { + syscallnum = VIOC_SYSCALL64; + is64 = 1; + ioctldata = &syscall64_data; + syscall64_data.syscall = (int)AFSCALL_CALL; + syscall64_data.param1 = param1; + syscall64_data.param2 = param2; + syscall64_data.param3 = param3; + syscall64_data.param4 = param4; + syscall64_data.param5 = param5; + syscall64_data.param6 = param6; + } else { +#endif + syscallnum = VIOC_SYSCALL; + ioctldata = &syscall_data; + syscall_data.syscall = AFSCALL_CALL; + syscall_data.param1 = param1; + syscall_data.param2 = param2; + syscall_data.param3 = param3; + syscall_data.param4 = param4; + syscall_data.param5 = param5; + syscall_data.param6 = param6; +#ifdef AFS_DARWIN100_ENV + } +#endif if(fd >= 0) { - error = ioctl(fd, VIOC_SYSCALL, &syscall_data); - close(fd); + error = ioctl(fd, syscallnum, ioctldata); + close(fd); } else { - error = -1; + error = -1; + } + if (!error) { +#ifdef AFS_DARWIN100_ENV + if (is64) + error=syscall64_data.retval; + else +#endif + error=syscall_data.retval; } - if (!error) - error=syscall_data.retval; #else error = syscall(AFS_SYSCALL, AFSCALL_CALL, param1, param2, param3, param4, diff --git a/src/cf/osconf.m4 b/src/cf/osconf.m4 index 5d2f027..98db277 100644 --- a/src/cf/osconf.m4 +++ b/src/cf/osconf.m4 @@ -563,7 +563,7 @@ case $AFS_SYSNAME in EXTRA_VLIBOBJS="fstab.o" SHLIB_LINKER="${MT_CC} -dynamiclib" SHLIB_SUFFIX="dylib" - RANLIB="ranlib -c" + RANLIB="ranlib" ;; *_darwin_100) diff --git a/src/config/afs_args.h b/src/config/afs_args.h index e599bda..2bd77ef 100644 --- a/src/config/afs_args.h +++ b/src/config/afs_args.h @@ -224,17 +224,30 @@ struct afsprocdata32 { #ifdef AFS_DARWIN80_ENV struct afssysargs { - unsigned long syscall; - unsigned long param1; - unsigned long param2; - unsigned long param3; - unsigned long param4; - unsigned long param5; - unsigned long param6; - unsigned long retval; + unsigned int syscall; + unsigned int param1; + unsigned int param2; + unsigned int param3; + unsigned int param4; + unsigned int param5; + unsigned int param6; + unsigned int retval; +}; + +/* args reordered to avoid alignment issues */ +struct afssysargs64 { + user_addr_t param1; + user_addr_t param2; + user_addr_t param3; + user_addr_t param4; + user_addr_t param5; + user_addr_t param6; + unsigned int syscall; + unsigned int retval; }; #define VIOC_SYSCALL_TYPE 'C' #define VIOC_SYSCALL _IOWR(VIOC_SYSCALL_TYPE,1,struct afssysargs) +#define VIOC_SYSCALL64 _IOWR(VIOC_SYSCALL_TYPE,2,struct afssysargs64) #define SYSCALL_DEV_FNAME "/dev/openafs_ioctl" #endif diff --git a/src/libafs/MakefileProto.DARWIN.in b/src/libafs/MakefileProto.DARWIN.in index 58792e2..d137bdb 100644 --- a/src/libafs/MakefileProto.DARWIN.in +++ b/src/libafs/MakefileProto.DARWIN.in @@ -41,19 +41,26 @@ KINCLUDES=-I${KROOT}/System/Library/Frameworks/Kernel.framework/Headers KOPTS_DBUG=-g - + +KOPTS_DBUG=-gdwarf-2 KOPTS_ppc=-static -nostdinc -nostdlib -fno-builtin -finline -fno-keep-inline-functions -msoft-float -mlong-branch -fsigned-bitfields -arch ppc -Dppc -DPPC -D__PPC__ -DPAGE_SIZE_FIXED -mcpu=750 -mmultiple -fschedule-insns -force_cpusubtype_ALL KOPTS_x86=-static -nostdinc -nostdlib -fno-builtin -finline -fno-keep-inline-functions -msoft-float -mlong-branch -fsigned-bitfields -arch i386 -Di386 -DI386 -D__I386__ -DPAGE_SIZE_FIXED -march=i686 -mpreferred-stack-boundary=2 -falign-functions=4 -KOPTS_amd64=-static -nostdinc -nostdlib -fno-builtin -finline -fno-keep-inline-functions -msoft-float -mlong-branch -fsigned-bitfields -arch x86_64 -Damd64 -DAMD64 -D__AMD64__ -DPAGE_SIZE_FIXED -march=x86-64 -mpreferred-stack-boundary=4 -falign-functions=4 +KOPTS_amd64=-static -nostdinc -nostdlib -fno-builtin -finline -fno-keep-inline-functions -msoft-float -mlong-branch -fsigned-bitfields -arch x86_64 -Damd64 -DAMD64 -D__AMD64__ -DPAGE_SIZE_FIXED -march=x86-64 -mpreferred-stack-boundary=4 -falign-functions=4 -m64 -mkernel -mno-red-zone ARCH_ppc=$(shell echo "${ARCHFLAGS}" | grep -q -w ppc && echo yes || echo ${ARCHFLAGS} | egrep -q -w -v 'ppc|i386|x86_64' && arch | grep -q -w ppc && echo yes) ARCH_x86=$(shell echo "${ARCHFLAGS}" | grep -q -w i386 && echo yes || echo ${ARCHFLAGS} | egrep -q -w -v 'ppc|i386|x86_64' && arch | grep -q -w i386 && echo yes) ARCH_amd64=$(shell echo "${ARCHFLAGS}" | grep -q -w x86_64 && echo yes || echo ${ARCHFLAGS} | egrep -q -w -v 'ppc|i386|x86_64' && arch | grep -q -w x86_64 && echo yes) OBJ_ppc=$(shell echo "${ARCH_ppc}" | grep -q -w yes && echo "$@.ppc") OBJ_x86=$(shell echo "${ARCH_x86}" | grep -q -w yes && echo "$@.x86") OBJ_amd64=$(shell echo "${ARCH_amd64}" | grep -q -w yes && echo "$@.amd64") + + +MODLD=$(CC) -static $(KOPTS_DBUG) -nostdlib $(ARCHFLAGS) -Xlinker -kext + MODLD=$(CC) -static $(KOPTS_DBUG) -nostdlib $(ARCHFLAGS) + CFLAGS_ppc=${KINCLUDES} -I. -I.. -I${TOP_OBJDIR}/src/config $(DEFINES) $(KDEFS) $(KOPTS_ppc) $(KOPTS_DBUG) CFLAGS_x86=${KINCLUDES} -I. -I.. -I${TOP_OBJDIR}/src/config $(DEFINES) $(KDEFS) $(KOPTS_x86) $(KOPTS_DBUG) diff --git a/src/rx/rx_clock.h b/src/rx/rx_clock.h index 6b13f79..b0f1175 100644 --- a/src/rx/rx_clock.h +++ b/src/rx/rx_clock.h @@ -90,7 +90,7 @@ extern int clock_nUpdates; #if defined(AFS_SGI61_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX_64BIT_KERNEL) #define clock_GetTime(cv) osi_GetTime((osi_timeval_t *)cv) #else -#if defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL) +#if (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)) || (defined(AFS_DARWIN100_ENV) && defined(__amd64__)) #define clock_GetTime(cv) \ BEGIN \ struct timeval tv; \ diff --git a/src/sys/glue.c b/src/sys/glue.c index f2c2d2c..fea5a2f 100644 --- a/src/sys/glue.c +++ b/src/sys/glue.c @@ -51,27 +51,52 @@ int proc_afs_syscall(long syscall, long param1, long param2, long param3, #if defined(AFS_DARWIN80_ENV) int ioctl_afs_syscall(long syscall, long param1, long param2, long param3, - long param4, long param5, long param6, int *rval) { - struct afssysargs syscall_data; - int code; - int fd = open(SYSCALL_DEV_FNAME, O_RDWR); - if(fd < 0) - return -1; - - syscall_data.syscall = syscall; - syscall_data.param1 = param1; - syscall_data.param2 = param2; - syscall_data.param3 = param3; - syscall_data.param4 = param4; - syscall_data.param5 = param5; - syscall_data.param6 = param6; - - code = ioctl(fd, VIOC_SYSCALL, &syscall_data); + long param4, long param5, long param6, int *rval) { + struct afssysargs syscall_data; + void *ioctldata; + int code; + int fd = open(SYSCALL_DEV_FNAME, O_RDWR); + int syscallnum; +#ifdef AFS_DARWIN100_ENV + struct afssysargs64 syscall64_data; + if (sizeof(param1) == 8) { + syscallnum = VIOC_SYSCALL64; + ioctldata = &syscall64_data; + syscall64_data.syscall = (int)syscall; + syscall64_data.param1 = param1; + syscall64_data.param2 = param2; + syscall64_data.param3 = param3; + syscall64_data.param4 = param4; + syscall64_data.param5 = param5; + syscall64_data.param6 = param6; + } else { +#endif + syscallnum = VIOC_SYSCALL; + ioctldata = &syscall_data; + syscall_data.syscall = syscall; + syscall_data.param1 = param1; + syscall_data.param2 = param2; + syscall_data.param3 = param3; + syscall_data.param4 = param4; + syscall_data.param5 = param5; + syscall_data.param6 = param6; +#ifdef AFS_DARWIN100_ENV + } +#endif + if(fd >= 0) { + code = ioctl(fd, syscallnum, ioctldata); + close(fd); + } else + code = -1; - close(fd); - if (code) - return code; - *rval=syscall_data.retval; - return 0; + if (code) + return code; +#ifdef AFS_DARWIN100_ENV + if (sizeof(param1) == 8) + *rval=syscall64_data.retval; + else +#endif + *rval=syscall_data.retval; + return 0; } #endif diff --git a/src/sys/setpag.c b/src/sys/setpag.c index 3d634f1..6d9a326 100644 --- a/src/sys/setpag.c +++ b/src/sys/setpag.c @@ -56,6 +56,8 @@ lsetpag(void) if(rval) errcode = syscall(AFS_SYSCALL, AFSCALL_SETPAG); +#elif defined(AFS_DARWIN80_ENV) + errcode = ioctl_afs_syscall(AFSCALL_SETPAG,0,0,0,0,0,0,&errcode); #else errcode = syscall(AFS_SYSCALL, AFSCALL_SETPAG); #endif -- 1.9.4