#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
*/
#include <afsconfig.h>
#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
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);
#endif
#undef gop_lookupname
#define gop_lookupname osi_lookupname
+#undef gop_lookupname_user
+#define gop_lookupname_user osi_lookupname_user
#define FTRUNC 0
#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
#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;
}
#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;
int afs_osi_ctxtp_initialized;
static thread_t vfs_context_owner;
-#define RECURSIVE_VFS_CONTEXT 1
-#if RECURSIVE_VFS_CONTEXT
static proc_t vfs_context_curproc;
int vfs_context_ref;
-#else
-#define vfs_context_ref 1
-#endif
-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 RECURSIVE_VFS_CONTEXT
- if (afs_osi_ctxtp && current_proc() == vfs_context_curproc) {
- vfs_context_ref++;
- vfs_context_owner = current_thread();
- if (!isglock)
- AFS_GUNLOCK();
- return;
- }
-#endif
- while (afs_osi_ctxtp && vfs_context_ref) {
- printf("[%d] waiting for afs_osi_ctxtp\n", proc_selfpid());
- afs_osi_Sleep(&afs_osi_ctxtp);
- if (afs_osi_ctxtp_initialized) {
- printf("[%d] ok\n", proc_selfpid());
- if (!isglock)
- AFS_GUNLOCK();
- return;
- }
- if (!afs_osi_ctxtp || !vfs_context_ref)
- printf("[%d] ok\n", proc_selfpid());
- }
-#if RECURSIVE_VFS_CONTEXT
- vfs_context_rele(afs_osi_ctxtp);
- vfs_context_ref=1;
-#else
- osi_Assert(vfs_context_owner == (thread_t)0);
-#endif
- 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 RECURSIVE_VFS_CONTEXT
- if (vfs_context_owner == current_thread())
- vfs_context_owner = (thread_t)0;
- vfs_context_ref--;
-#else
- osi_Assert(vfs_context_owner == current_thread());
- vfs_context_rele(afs_osi_ctxtp);
- afs_osi_ctxtp = NULL;
- vfs_context_owner = (thread_t)0;
-#endif
- 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;
}
/* 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);
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);
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);
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->states & CStatd && size != avc->m.Length)
ubc_setsize(vp, avc->m.Length);
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);
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);
if (((ap->a_command >> 8) & 0xff) == 'V') {
/* This is a VICEIOCTL call */
AFS_GLOCK();
- error = HandleIoctl(tvc, (struct file *)0 /*Not used */ ,
+ error = HandleIoctl(tvc,
ap->a_command, ap->a_data);
AFS_GUNLOCK();
return (error);
#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))
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
#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
#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))
}
return code;
}
+
int
osi_lookupname(char *aname, uio_seg_t seg, int followlink,
- struct dentry **dpp)
+ struct dentry **dpp)
{
int code;
char *tname;
#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)); } \
#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
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)
#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)
#define afs_suser(x) suser(x)
#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 */
};
afs_int32 afs_rx_harddead = AFS_HARDDEADTIME;
afs_int32 afs_rx_idledead = AFS_IDLEDEADTIME;
+#ifdef AFS_DARWIN100_ENV
+static int
+Afscall64_icl(int opcode, user_addr_t kp1, user_addr_t kp2, user_addr_t kp3, user_addr_t kp4, int *retval);
+#endif
static int
Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval);
#endif
}
-/* leaving as is, probably will barf if we add prototypes here since it's likely being called
-with partial list */
+#ifdef AFS_DARWIN100_ENV
+#define AFSKPTR(X) k ## X
int
-afs_syscall_call(parm, parm2, parm3, parm4, parm5, parm6)
- long parm, parm2, parm3, parm4, parm5, 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)
#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 (
* home cell flag (0x1 bit) and the nosuid flag (0x2 bit) */
struct afsop_cell *tcell = afs_osi_Alloc(sizeof(struct afsop_cell));
- 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);
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;
char *aliasName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
char *cellName = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
- 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);
*/
char *cell = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
- AFS_COPYINSTR((char *)parm2, cell, AFS_SMALLOCSIZ, &bufferSize, code);
+ AFS_COPYINSTR(AFSKPTR(parm2), cell, AFS_SMALLOCSIZ, &bufferSize, code);
if (!code)
afs_SetPrimaryCell(cell);
osi_FreeSmallSpace(cell);
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);
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
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);
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);
#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
#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) {
#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)
}
}
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);
}
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();
#else /* AFS_SGI_ENV */
struct iparam {
- long param1;
- long param2;
- long param3;
- long param4;
+ iparmtype param1;
+ iparmtype param2;
+ iparmtype param3;
+ iparmtype param4;
};
struct iparam32 {
/*
* 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
{
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;
{
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
#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
-#if defined(AFS_HPUX_ENV)
- /*
- * There used to be code here (duplicated from osi_Init()) for
- * initializing the semaphore used by AFS_GLOCK(). Was the
- * duplication to handle the case of a dynamically loaded kernel
- * module?
- */
- osi_InitGlock();
+ uap = (struct afssysa *)args;
#endif
- if (uap->syscall == AFSCALL_CALL) {
+#if defined(AFS_HPUX_ENV)
+ /*
+ * There used to be code here (duplicated from osi_Init()) for
+ * initializing the semaphore used by AFS_GLOCK(). Was the
+ * duplication to handle the case of a dynamically loaded kernel
+ * module?
+ */
+ osi_InitGlock();
+#endif
+ if (uap->syscall == AFSCALL_CALL) {
+ code =
+ afs_syscall_call(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
+ uap->parm5, uap->parm6
#ifdef AFS_SUN5_ENV
- code =
- afs_syscall_call(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
- uap->parm5, uap->parm6, rvp, CRED());
-#else
- code =
- afs_syscall_call(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
- uap->parm5, uap->parm6);
+ , rvp, CRED()
#endif
- } else if (uap->syscall == AFSCALL_SETPAG) {
+ );
+ } else if (uap->syscall == AFSCALL_SETPAG) {
#ifdef AFS_SUN5_ENV
- register proc_t *procp;
-
- procp = ttoproc(curthread);
- AFS_GLOCK();
- code = afs_setpag(&procp->p_cred);
- AFS_GUNLOCK();
+ register proc_t *procp;
+
+ 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(uap->parm1, uap->parm2, uap->parm3,
- uap->parm4);
-#endif
- AFS_GUNLOCK();
- } else if (uap->syscall == AFSCALL_ICREATE) {
- struct iparam iparams;
-
- code = copyin_iparam((char *)uap->parm3, &iparams);
- if (code) {
+ code =
+ afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
+ uap->parm4);
+#endif
+ AFS_GUNLOCK();
+ } else if (uap->syscall == AFSCALL_ICREATE) {
+ struct iparam iparams;
+
+ code = copyin_iparam((char *)uap->parm3, &iparams);
+ if (code) {
#if defined(KERNEL_HAVE_UERROR)
- setuerror(code);
-#endif
- } else
+ setuerror(code);
+#endif
+ } else {
+ code =
+ afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1,
+ iparams.param2, iparams.param3,
+ iparams.param4
+#ifdef AFS_SUN5_ENV
+ , rvp, CRED()
+#elif defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+ , retval
+#endif
+ );
+ }
+ } else if (uap->syscall == AFSCALL_IOPEN) {
+ code =
+ afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3
#ifdef AFS_SUN5_ENV
- 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,
-#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
- iparams.param3, iparams.param4, retval);
-#else
- iparams.param3, iparams.param4);
-#endif
-#endif /* AFS_SUN5_ENV */
- } else if (uap->syscall == AFSCALL_IOPEN) {
+ , rvp, CRED()
+#elif defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+ , retval
+#endif
+ );
+ } else if (uap->syscall == AFSCALL_IDEC) {
+ code =
+ afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, -1
#ifdef AFS_SUN5_ENV
- code =
- afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3, rvp,
- CRED());
-#else
-#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);
+ , rvp, CRED()
#endif
-#endif /* AFS_SUN5_ENV */
- } else if (uap->syscall == AFSCALL_IDEC) {
+ );
+ } 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_IINC) {
-#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;
extern struct afs_icl_set *afs_icl_FindSet();
+#ifdef AFS_DARWIN100_ENV
+#define AFSKPTR(X) k ## X
+static 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
+
static 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;
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 */
* 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;
logp = afs_icl_FindLog(tname);
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;
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;
/* 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);
* and kernel space. Call these to avoid taking page faults while
* holding the global lock.
*/
-#ifdef CAST_USER_ADDR_T
+#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)
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)
}
#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);
}
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);
*/
static 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)
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
int
#ifdef AFS_SUN5_ENV
-afs_syscall_pioctl(path, com, cmarg, follow, rvp, credp)
- rval_t *rvp;
- struct AFS_UCRED *credp;
+afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow, rval_t *rvp, struct AFS_UCRED *credp)
#else
-#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
-afs_syscall_pioctl(path, com, cmarg, follow, credp)
- struct AFS_UCRED *credp;
+#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
-afs_syscall_pioctl(path, com, cmarg, follow)
+afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow)
#endif
#endif
- char *path;
- unsigned int com;
- caddr_t cmarg;
- int follow;
{
struct afs_ioctl data;
#ifdef AFS_NEED_CLIENTCONTEXT
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();
#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)
}
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;
extern void afs_shutdown(void);
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 */
/* afs_exporter.c */
extern struct afs_exporter *root_exported;
extern struct afs_exporter *exporter_find(int type);
+extern void shutdown_exporter(void);
/* afs_init.c */
extern struct cm_initparams cm_initParams;
extern short afs_waitForeverCount;
extern afs_int32 afs_showflags;
extern int afs_defaultAsynchrony;
-extern int afs_syscall_pioctl();
+#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);
+#elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+extern int afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg,
+ int follow, struct AFS_UCRED *credp);
+#else
+extern int afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg,
+ int follow);
+#endif
+extern int HandleIoctl(register struct vcache *avc, register afs_int32 acom,
+ struct afs_ioctl *adata);
+
/* afs_segments.c */
extern int afs_StoreMini(register struct vcache *avc, struct vrequest *areq);
extern void afs_AddToMean(struct afs_MeanStats *oldMean, afs_int32 newValue);
#endif
-
/* UKERNEL/afs_usrops.c */
#ifdef UKERNEL
extern void uafs_Shutdown(void);
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;
}
#if !defined(AFS_SGI_ENV) && !defined(AFS_AIX32_ENV)
-
-call_syscall(param1, param2, param3, param4, param5, param6, param7)
- long param1, param2, param3, param4, param5, param6, param7;
+int
+call_syscall(long param1, long param2, long param3, long param4, long param5,
+ long param6, long param7)
{
int error;
#ifdef AFS_LINUX20_ENV
#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,
EXTRA_VLIBOBJS="fstab.o"
SHLIB_LINKER="${MT_CC} -dynamiclib"
SHLIB_SUFFIX="dylib"
- RANLIB="ranlib -c"
+ RANLIB="ranlib"
;;
*_darwin_100)
#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
<ppc_darwin_80 x86_darwin_80>
KOPTS_DBUG=-g
-<ppc_darwin_90 x86_darwin_90 x86_darwin_100>
+<ppc_darwin_90 x86_darwin_90
KOPTS_DBUG=-ggdb
+< x86_darwin_100>
+KOPTS_DBUG=-gdwarf-2
<ppc_darwin_80 x86_darwin_80 ppc_darwin_90 x86_darwin_90 x86_darwin_100>
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")
+
+<ppc_darwin_90 x86_darwin_90 x86_darwin_100>
+MODLD=$(CC) -static $(KOPTS_DBUG) -nostdlib $(ARCHFLAGS) -Xlinker -kext
+<all -ppc_darwin_90 -x86_darwin_90 -x86_darwin_100>
MODLD=$(CC) -static $(KOPTS_DBUG) -nostdlib $(ARCHFLAGS)
+<all>
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)
#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; \
PTSERVER = ../ptserver
SYS = ../sys
-AUDITOBJS = audit.o audit-file.o audit-sysvmq.o
+AUDITOBJS = audit.o
AUTHOBJS = \
cellconfig.o \
#endif /* AFS_NAMEI_ENV */
-#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);
-
- close(fd);
- if (code)
- return code;
- *rval=syscall_data.retval;
- return 0;
-}
-#endif
-
int
lpioctl(char *path, int cmd, char *cmarg, int follow)
{
return 0;
}
#endif
+
+#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;
+ 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;
+
+ 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
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
afs_int32 Maxvolidbump;
afs_int32 *newvolumeid;
{
- register afs_int32 errorcode, maxvolumeid;
+ afs_int32 errorcode, maxvolumeid;
struct ubik_trans *trans;
COUNT_REQ(VLGETNEWVOLUMEID);
projects / packages / o / openafs.git / commitdiff