macos104-not-yet-20050511
authorChaskiel M Grundman <cg2v@andrew.cmu.edu>
Thu, 12 May 2005 19:30:35 +0000 (19:30 +0000)
committerDerrick Brashear <shadow@dementia.org>
Thu, 12 May 2005 19:30:35 +0000 (19:30 +0000)
further work

====================
This delta was composed from multiple commits as part of the CVS->Git migration.
The checkin message with each commit was inconsistent.
The following are the additional commit messages.
====================

ifaddr/ifnet compat macros for older versions, and clean up afs_server interface ot use it.

fix vnode_isinuse macros

====================

further work

====================

further work

17 files changed:
src/afs/DARWIN/osi_machdep.h
src/afs/DARWIN/osi_misc.c
src/afs/VNOPS/afs_vnop_read.c
src/afs/VNOPS/afs_vnop_write.c
src/afs/afs_callback.c
src/afs/afs_init.c
src/afs/afs_memcache.c
src/afs/afs_osi.c
src/afs/afs_osi.h
src/afs/afs_osi_pag.c
src/afs/afs_osi_uio.c
src/afs/afs_osi_vget.c
src/afs/afs_server.c
src/afs/afs_util.c
src/afs/afs_vcache.c
src/config/param.ppc_darwin_80.h
src/libafs/MakefileProto.DARWIN.in

index af96c10..14bc7dd 100644 (file)
@@ -29,9 +29,9 @@ typedef unsigned short etap_event_t;
 #include <kern/locks.h>
 #else
 #include <sys/lock.h>
+#include <sys/user.h>
 #endif
 #include <kern/thread.h>
-#include <sys/user.h>
 
 #ifdef AFS_DARWIN80_ENV
 #define getpid()                proc_selfpid()
@@ -48,10 +48,35 @@ typedef unsigned short etap_event_t;
 /* vcexcl - used only by afs_create */
 enum vcexcl { EXCL, NONEXCL };
 
+#ifndef AFS_DARWIN80_ENV
+#define ifaddr_address_family(x) (x)->ifa_addr->sa_family
+#define ifaddr_address(x, y, z) memcpy(y, (x)->ifa_addr, z)
+#define ifaddr_netmask(x, y, z) memcpy(y, (x)->ifa_netmask, z)
+#define ifaddr_dstaddress(x, y, z) memcpy(y, (x)->ifa_dstaddr, z)
+#define ifaddr_ifnet(x) (x?(x)->ifa_ifp:0)
+#define ifnet_flags(x) (x?(x)->if_flags:0)
+#define ifnet_metric(x) (x?(x)->if_data.ifi_metric:0)
+#endif
+
 #ifdef AFS_DARWIN80_ENV
 #define vrele vnode_rele
 #define vput vnode_put
 #define vref vnode_ref
+#define vattr vnode_attr
+
+#define SetAfsVnode(vn)         /* nothing; done in getnewvnode() */
+/* vnode_vfsfsprivate is not declared, so no macro for us */
+extern void * afs_fsprivate_data;
+static inline int IsAfsVnode(vnode_t vn) {
+   mount_t mp;
+   int res = 0;
+   mp = vnode_mount(vn);
+   if (mp) {
+      res = (vfs_fsprivate(mp) == &afs_fsprivate_data);
+      vfs_mountrelease(mp);
+   }
+   return res;
+}
 #endif
 
 /* 
@@ -60,7 +85,15 @@ enum vcexcl { EXCL, NONEXCL };
 #ifndef AFS_DARWIN60_ENV
 extern struct timeval time;
 #endif
+#ifdef AFS_DARWIN80_ENV
+static inline time_t osi_Time(void) {
+    struct timeval _now;
+    microtime(&_now);
+    return _now.tv_sec;
+}
+#else
 #define osi_Time() (time.tv_sec)
+#endif
 #define afs_hz      hz
 
 #define PAGESIZE 8192
@@ -133,14 +166,18 @@ extern struct lock__bsd__ afs_global_lock;
 #define AFS_APPL_UFS_CACHE 1
 #define AFS_APPL_HFS_CACHE 2
 
-extern ino_t VnodeToIno(vnode_t * vp);
-extern dev_t VnodeToDev(vnode_t * vp);
+extern ino_t VnodeToIno(struct vnode * vp);
+extern dev_t VnodeToDev(struct vnode * vp);
 
 #define osi_curproc() current_proc()
 
 /* FIXME */
 #define osi_curcred() &afs_osi_cred 
 
+#ifdef AFS_DARWIN80_ENV
+uio_t afsio_darwin_partialcopy(uio_t auio, int size);
+#endif
+
 #endif /* KERNEL */
 
 #endif /* _OSI_MACHDEP_H_ */
index 701b091..c776154 100644 (file)
@@ -17,6 +17,29 @@ RCSID
 #include "afsincludes.h"
 #include <sys/namei.h>
 
+#ifdef AFS_DARWIN80_ENV
+int
+osi_lookupname(char *aname, enum uio_seg seg, int followlink,
+              struct vnode **vpp) {
+  vfs_context_t ctx;
+  char tname[PATHBUFLEN];
+  int len, code, flags;
+
+  if (seg == AFS_UIOUSER) { /* XXX 64bit */
+     AFS_COPYINSTR(aname, tname, PATHBUFLEN, code);
+     if (code)
+       return code;
+     aname=tname;
+  }
+  flags = 0
+  if (!followlink)
+       flag |= VNODE_LOOKUP_NOFOLLOW;
+  ctx=vfs_context_create(NULL);
+  code = vnode_lookup(aname, flags, vpp, ctx);
+  vfs_context_rele(ctx);
+  return code;
+}
+#else
 int
 osi_lookupname(char *aname, enum uio_seg seg, int followlink,
               struct vnode **vpp)
@@ -37,20 +60,50 @@ osi_lookupname(char *aname, enum uio_seg seg, int followlink,
     VOP_UNLOCK(n.ni_vp, 0, current_proc());
     return 0;
 }
+#endif
 
 /*
  * afs_suser() returns true if the caller is superuser, false otherwise.
  *
  * Note that it must NOT set errno.
  */
-
+int
 afs_suser(void *credp)
 {
     int error;
     struct proc *p = current_proc();
 
+#if AFS_DARWIN80_ENV
+    return proc_suser(p);
+#else
     if ((error = suser(p->p_ucred, &p->p_acflag)) == 0) {
        return (1);
     }
     return (0);
+#endif
+}
+
+#ifdef AFS_DARWIN80_ENV
+uio_t afsio_darwin_partialcopy(uio_t auio, int size) {
+   uio_t res;
+   int index;
+   user_addr_t iovaddr;
+   user_size_r iovsize;
+
+   /* XXX 64 bit userspaace? */
+   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, index, &iovaddr, &iovsize))
+           break;
+       if (iovsize > size)
+          iovsize = size;
+       if (uio_addiov(res, iovaddr, iovsize))
+          break;
+       size -= iovsize;
+   }
+   return res;
 }
+#endif
index 5efc7b4..c561e8f 100644 (file)
@@ -60,8 +60,13 @@ afs_MemRead(register struct vcache *avc, struct uio *auio,
     afs_int32 trimlen;
     struct dcache *tdc = 0;
     afs_int32 error, trybusy = 1;
+#ifdef AFS_DARWIN80_ENV
+    uio_t tuiop;
+#else
     struct uio tuio;
+    struct uio *tuiop = &tuio;
     struct iovec *tvec;
+#endif
     afs_int32 code;
     struct vrequest treq;
 
@@ -89,9 +94,11 @@ afs_MemRead(register struct vcache *avc, struct uio *auio,
     }
 #endif
 
+#ifndef AFS_DARWIN80_ENV
     tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));
-    totalLength = auio->afsio_resid;
-    filePos = auio->afsio_offset;
+#endif
+    totalLength = AFS_UIO_RESID(auio);
+    filePos = AFS_UIO_OFFSET(auio);
     afs_Trace4(afs_iclSetp, CM_TRACE_READ, ICL_TYPE_POINTER, avc,
               ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(filePos), ICL_TYPE_INT32,
               totalLength, ICL_TYPE_OFFSET,
@@ -301,10 +308,15 @@ afs_MemRead(register struct vcache *avc, struct uio *auio,
                len = tlen;
            if (len > AFS_ZEROS)
                len = sizeof(afs_zeros);        /* and in 0 buffer */
+#ifdef AFS_DARWIN80_ENV
+           trimlen = len;
+            tuiop = afsio_darwin_partialcopy(auio, trimlen);
+#else
            afsio_copy(auio, &tuio, tvec);
            trimlen = len;
            afsio_trim(&tuio, trimlen);
-           AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, &tuio, code);
+#endif
+           AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, tuiop, code);
            if (code) {
                error = code;
                break;
@@ -313,12 +325,18 @@ afs_MemRead(register struct vcache *avc, struct uio *auio,
            /* get the data from the mem cache */
 
            /* mung uio structure to be right for this transfer */
+#ifdef AFS_DARWIN80_ENV
+           trimlen = len;
+            tuiop = afsio_darwin_partialcopy(auio, trimlen);
+           uio_setoffset(tuiop, offset);
+#else
            afsio_copy(auio, &tuio, tvec);
            trimlen = len;
            afsio_trim(&tuio, trimlen);
            tuio.afsio_offset = offset;
+#endif
 
-           code = afs_MemReadUIO(tdc->f.inode, &tuio);
+           code = afs_MemReadUIO(tdc->f.inode, tuiop);
 
            if (code) {
                error = code;
@@ -326,7 +344,7 @@ afs_MemRead(register struct vcache *avc, struct uio *auio,
            }
        }
        /* otherwise we've read some, fixup length, etc and continue with next seg */
-       len = len - tuio.afsio_resid;   /* compute amount really transferred */
+       len = len - AFS_UIO_RESID(tuiop);       /* compute amount really transferred */
        trimlen = len;
        afsio_skip(auio, trimlen);      /* update input uio structure */
        totalLength -= len;
@@ -359,7 +377,11 @@ afs_MemRead(register struct vcache *avc, struct uio *auio,
     }
     if (!noLock)
        ReleaseReadLock(&avc->lock);
+#ifdef AFS_DARWIN80_ENV
+    uio_free(tuiop);
+#else
     osi_FreeSmallSpace(tvec);
+#endif
     error = afs_CheckCode(error, &treq, 10);
     return error;
 }
@@ -448,8 +470,13 @@ afs_UFSRead(register struct vcache *avc, struct uio *auio,
     afs_int32 trimlen;
     struct dcache *tdc = 0;
     afs_int32 error;
+#ifdef AFS_DARWIN80_ENV
+    uio_t tuiop;
+#else
     struct uio tuio;
+    struct uio *tuio = &tuio;
     struct iovec *tvec;
+#endif
     struct osi_file *tfile;
     afs_int32 code;
     int trybusy = 1;
@@ -483,9 +510,11 @@ afs_UFSRead(register struct vcache *avc, struct uio *auio,
     }
 #endif
 
+#ifndef AFS_DARWIN80_ENV
     tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));
-    totalLength = auio->afsio_resid;
-    filePos = auio->afsio_offset;
+#endif
+    totalLength = AFS_UIO_RESID(auio);
+    filePos = AFS_UIO_OFFSET(auio);
     afs_Trace4(afs_iclSetp, CM_TRACE_READ, ICL_TYPE_POINTER, avc,
               ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(filePos), ICL_TYPE_INT32,
               totalLength, ICL_TYPE_OFFSET,
@@ -686,10 +715,15 @@ afs_UFSRead(register struct vcache *avc, struct uio *auio,
                len = tlen;
            if (len > AFS_ZEROS)
                len = sizeof(afs_zeros);        /* and in 0 buffer */
+#ifdef AFS_DARWIN80_ENV
+           trimlen = len;
+            tuiop = afsio_darwin_partialcopy(auio, trimlen);
+#else
            afsio_copy(auio, &tuio, tvec);
            trimlen = len;
            afsio_trim(&tuio, trimlen);
-           AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, &tuio, code);
+#endif
+           AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, tuiop, code);
            if (code) {
                error = code;
                break;
@@ -712,11 +746,18 @@ afs_UFSRead(register struct vcache *avc, struct uio *auio,
 #endif /* IHINT */
 
                tfile = (struct osi_file *)osi_UFSOpen(tdc->f.inode);
+#ifdef AFS_DARWIN80_ENV
+           trimlen = len;
+            tuiop = afsio_darwin_partialcopy(auio, trimlen);
+           uio_setoffset(tuiop, offset);
+#else
            /* mung uio structure to be right for this transfer */
            afsio_copy(auio, &tuio, tvec);
            trimlen = len;
            afsio_trim(&tuio, trimlen);
            tuio.afsio_offset = offset;
+#endif
+
 #if defined(AFS_AIX41_ENV)
            AFS_GUNLOCK();
            code =
@@ -796,6 +837,16 @@ afs_UFSRead(register struct vcache *avc, struct uio *auio,
            code = VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp);
            VOP_UNLOCK(tfile->vnode, 0, current_proc());
            AFS_GLOCK();
+#elif defined(AFS_DARWIN80_ENV)
+           AFS_GUNLOCK();
+           code = VOP_READ(tfile->vnode, tuiop, 0, afs_osi_ctxp);
+           AFS_GLOCK();
+#elif defined(AFS_DARWIN_ENV)
+           AFS_GUNLOCK();
+           VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
+           code = VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp);
+           VOP_UNLOCK(tfile->vnode, 0, current_proc());
+           AFS_GLOCK();
 #elif defined(AFS_FBSD50_ENV)
            AFS_GUNLOCK();
            VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curthread);
@@ -826,7 +877,7 @@ afs_UFSRead(register struct vcache *avc, struct uio *auio,
            }
        }
        /* otherwise we've read some, fixup length, etc and continue with next seg */
-       len = len - tuio.afsio_resid;   /* compute amount really transferred */
+       len = len - AFS_UIO_RESID(tuiop);       /* compute amount really transferred */
        trimlen = len;
        afsio_skip(auio, trimlen);      /* update input uio structure */
        totalLength -= len;
@@ -854,7 +905,11 @@ afs_UFSRead(register struct vcache *avc, struct uio *auio,
     if (!noLock)
        ReleaseReadLock(&avc->lock);
 
+#ifdef AFS_DARWIN80_ENV
+    uio_free(tuiop);
+#else
     osi_FreeSmallSpace(tvec);
+#endif
     error = afs_CheckCode(error, &treq, 13);
     return error;
 }
index 4a93e55..0d90649 100644 (file)
@@ -105,8 +105,13 @@ afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
     volatile
 #endif
     afs_int32 error;
+#ifdef AFS_DARWIN80_ENV
+    uio_t tuiop;
+#else
     struct uio tuio;
+    struct uio *tuiop = &tuio;
     struct iovec *tvec;                /* again, should have define */
+#endif
     register afs_int32 code;
     struct vrequest treq;
 
@@ -253,13 +258,20 @@ afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
             * as will fit */
            len = max - offset;
        }
+
+#ifdef  AFS_DARWIN80_ENV
+       trimlen = len;
+       tuiop = afsio_darwin_partialcopy(auio, trimlen);
+       uio_setoffset(tuiop, offset);
+#else
        /* mung uio structure to be right for this transfer */
        afsio_copy(auio, &tuio, tvec);
        trimlen = len;
        afsio_trim(&tuio, trimlen);
        tuio.afsio_offset = offset;
+#endif
 
-       code = afs_MemWriteUIO(tdc->f.inode, &tuio);
+       code = afs_MemWriteUIO(tdc->f.inode, tuiop);
        if (code) {
            void *mep;          /* XXX in prototype world is struct memCacheEntry * */
            error = code;
@@ -274,7 +286,7 @@ afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
            break;
        }
        /* otherwise we've written some, fixup length, etc and continue with next seg */
-       len = len - tuio.afsio_resid;   /* compute amount really transferred */
+       len = len - AFS_UIO_RESID(tuiop);       /* compute amount really transferred */
        tlen = len;
        afsio_skip(auio, tlen); /* advance auio over data written */
        /* compute new file size */
@@ -322,7 +334,11 @@ afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
        avc->vc_error = error;
     if (!noLock)
        ReleaseWriteLock(&avc->lock);
+#ifdef AFS_DARWIN80_ENV
+    uio_free(tuiop);
+#else
     osi_FreeSmallSpace(tvec);
+#endif
     error = afs_CheckCode(error, &treq, 6);
     return error;
 }
@@ -346,8 +362,13 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
     volatile
 #endif
     afs_int32 error;
+#ifdef AFS_DARWIN80_ENV
+    uio_t tuiop;
+#else
     struct uio tuio;
+    struct uio *tuiop = &tuio;
     struct iovec *tvec;                /* again, should have define */
+#endif
     struct osi_file *tfile;
     register afs_int32 code;
     struct vrequest treq;
@@ -392,7 +413,12 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
 #if     defined(AFS_SUN56_ENV)
        auio->uio_loffset = 0;
 #endif
-       filePos = auio->afsio_offset = avc->m.Length;
+       filePos = avc->m.Length;
+#ifdef AFS_DARWIN80_ENV
+       uio_setoffset(auio, avc->m.Length);
+#else
+       auio->afsio_offset = avc->m.Length;
+#endif
     }
 #endif
     /*
@@ -426,7 +452,9 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
     afs_FakeOpen(avc);
 #endif
     avc->states |= CDirty;
+#ifndef AFS_DARWIN80_ENV
     tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));
+#endif
     while (totalLength > 0) {
        /* 
         *  The following line is necessary because afs_GetDCache with
@@ -498,11 +526,19 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
             * as will fit */
            len = max - offset;
        }
+
+#ifdef  AFS_DARWIN80_ENV
+       trimlen = len;
+       tuiop = afsio_darwin_partialcopy(auio, trimlen);
+       uio_setoffset(tuiop, offset);
+#else
        /* mung uio structure to be right for this transfer */
        afsio_copy(auio, &tuio, tvec);
        trimlen = len;
        afsio_trim(&tuio, trimlen);
        tuio.afsio_offset = offset;
+#endif
+
 #if defined(AFS_AIX41_ENV)
        AFS_GUNLOCK();
        code =
@@ -562,6 +598,10 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
        AFS_GUNLOCK();
        code = osi_rdwr(tfile, &tuio, UIO_WRITE);
        AFS_GLOCK();
+#elif defined(AFS_DARWIN80_ENV)
+       AFS_GUNLOCK();
+       code = VOP_WRITE(tfile->vnode, tuiop, 0, afs_osi_ctxtp);
+       AFS_GLOCK();
 #elif defined(AFS_DARWIN_ENV)
        AFS_GUNLOCK();
        VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
@@ -599,7 +639,7 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
            break;
        }
        /* otherwise we've written some, fixup length, etc and continue with next seg */
-       len = len - tuio.afsio_resid;   /* compute amount really transferred */
+       len = len - AFS_UIO_RESID(tuiop);       /* compute amount really transferred */
        tlen = len;
        afsio_skip(auio, tlen); /* advance auio over data written */
        /* compute new file size */
@@ -650,7 +690,11 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
        avc->vc_error = error;
     if (!noLock)
        ReleaseWriteLock(&avc->lock);
+#ifdef AFS_DARWIN80_ENV
+    uio_free(tuiop);
+#else
     osi_FreeSmallSpace(tvec);
+#endif
 #ifndef        AFS_VM_RDWR_ENV
     /*
      * If write is implemented via VM, afs_fsync() is called from the high-level
index 9bc9653..ec73310 100644 (file)
@@ -152,7 +152,7 @@ SRXAFSCB_GetCE(struct rx_call *a_call, afs_int32 a_index,
     a_result->callback = afs_data_pointer_to_int32(tvc->callback);     /* XXXX Now a pointer; change it XXXX */
     a_result->cbExpires = tvc->cbExpires;
 #ifdef AFS_DARWIN80_ENV
-    a_result->refCount = vnode_isinuse(AFSTOV(tvc))?1:0; /* XXX fix */
+    a_result->refCount = vnode_isinuse(AFSTOV(tvc),0)?1:0; /* XXX fix */
 #else
     a_result->refCount = VREFCOUNT(tvc);
 #endif
@@ -235,7 +235,7 @@ SRXAFSCB_GetCE64(struct rx_call *a_call, afs_int32 a_index,
     a_result->callback = afs_data_pointer_to_int32(tvc->callback);     /* XXXX Now a pointer; change it XXXX */
     a_result->cbExpires = tvc->cbExpires;
 #ifdef AFS_DARWIN80_ENV
-    a_result->refCount = vnode_isinuse(AFSTOV(tvc))?1:0; /* XXX fix */
+    a_result->refCount = vnode_isinuse(AFSTOV(tvc),0)?1:0; /* XXX fix */
 #else
     a_result->refCount = VREFCOUNT(tvc);
 #endif
index 219bd8b..a429ed3 100644 (file)
@@ -381,6 +381,9 @@ afs_InitCacheInfo(register char *afile)
            VFS_STATFS(filevp->v_vfsp, &st);
            TO_KERNEL_SPACE();
        }
+#elif defined(AFS_DARWIN80_ENV)
+        afs_cacheVfsp = vnode_mount(filevp);
+       if (afs_cacheVfsp && !VFS_STATFS(afs_cacheVfsp, &st, current_proc()))
 #elif defined(AFS_DARWIN_ENV)
        if (!VFS_STATFS(filevp->v_mount, &st, current_proc()))
 #elif defined(AFS_FBSD50_ENV)
@@ -413,7 +416,9 @@ afs_InitCacheInfo(register char *afile)
 #endif
     cacheInode = afs_vnodeToInumber(filevp);
     cacheDev.dev = afs_vnodeToDev(filevp);
+#ifndef AFS_DARWIN80_ENV
     afs_cacheVfsp = filevp->v_vfsp;
+#endif
 #endif /* AFS_LINUX20_ENV */
     AFS_RELE(filevp);
 #endif /* AFS_LINUX22_ENV */
index 786ec62..279238b 100644 (file)
@@ -181,13 +181,13 @@ afs_MemReadUIO(ino_t blkno, struct uio *uioP)
 {
     register struct memCacheEntry *mceP =
        (struct memCacheEntry *)afs_MemCacheOpen(blkno);
-    int length = mceP->size - uioP->uio_offset;
+    int length = mceP->size - AFS_UIO_OFFSET(uioP);
     afs_int32 code;
 
     AFS_STATCNT(afs_MemReadUIO);
     MObtainReadLock(&mceP->afs_memLock);
-    length = (length < uioP->uio_resid) ? length : uioP->uio_resid;
-    AFS_UIOMOVE(mceP->data + uioP->uio_offset, length, UIO_READ, uioP, code);
+    length = (length < AFS_UIO_RESID(uioP)) ? length : AFS_UIO_RESID(uioP);
+    AFS_UIOMOVE(mceP->data + AFS_UIO_OFFSET(uioP), length, UIO_READ, uioP, code);
     MReleaseReadLock(&mceP->afs_memLock);
     return code;
 }
@@ -282,25 +282,25 @@ afs_MemWriteUIO(ino_t blkno, struct uio *uioP)
 
     AFS_STATCNT(afs_MemWriteUIO);
     MObtainWriteLock(&mceP->afs_memLock, 312);
-    if (uioP->uio_resid + uioP->uio_offset > mceP->dataSize) {
+    if (AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP) > mceP->dataSize) {
        char *oldData = mceP->data;
 
-       mceP->data = afs_osi_Alloc(uioP->uio_resid + uioP->uio_offset);
+       mceP->data = afs_osi_Alloc(AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP));
 
        AFS_GUNLOCK();
        memcpy(mceP->data, oldData, mceP->size);
        AFS_GLOCK();
 
        afs_osi_Free(oldData, mceP->dataSize);
-       mceP->dataSize = uioP->uio_resid + uioP->uio_offset;
+       mceP->dataSize = AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP);
     }
-    if (mceP->size < uioP->uio_offset)
+    if (mceP->size < AFS_UIO_OFFSET(uioP))
        memset(mceP->data + mceP->size, 0,
-              (int)(uioP->uio_offset - mceP->size));
-    AFS_UIOMOVE(mceP->data + uioP->uio_offset, uioP->uio_resid, UIO_WRITE,
+              (int)(AFS_UIO_OFFSET(uioP) - mceP->size));
+    AFS_UIOMOVE(mceP->data + AFS_UIO_OFFSET(uioP), AFS_UIO_RESID(uioP), UIO_WRITE,
                uioP, code);
-    if (uioP->uio_offset > mceP->size)
-       mceP->size = uioP->uio_offset;
+    if (AFS_UIO_OFFSET(uioP) > mceP->size)
+       mceP->size = AFS_UIO_OFFSET(uioP);
 
     MReleaseWriteLock(&mceP->afs_memLock);
     return code;
index 3443913..7b6d260 100644 (file)
@@ -286,6 +286,7 @@ afs_osi_Invisible(void)
     curproc->p_flag |= SSYS;
 #elif defined(AFS_HPUX101_ENV) && !defined(AFS_HPUX1123_ENV)
     set_system_proc(u.u_procp);
+#elif defined(AFS_DARWIN80_ENV)
 #elif defined(AFS_DARWIN_ENV)
     /* maybe call init_process instead? */
     current_proc()->p_flag |= P_SYSTEM;
@@ -767,7 +768,7 @@ afs_osi_TraverseProcTable(void)
 }
 #endif
 
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if (defined(AFS_DARWIN_ENV) && !defined(AFS_DARWIN80_ENV)) || defined(AFS_FBSD_ENV)
 void
 afs_osi_TraverseProcTable(void)
 {
@@ -991,6 +992,25 @@ afs_osi_proc2cred(AFS_PROC * pr)
 
     return rv;
 }
+#elif defined(AFS_DARWIN80_ENV) 
+const struct AFS_UCRED *
+afs_osi_proc2cred(AFS_PROC * pr)
+{
+    struct AFS_UCRED *rv = NULL;
+    static struct AFS_UCRED cr;
+    struct ucred *pcred;
+
+    if (pr == NULL) {
+       return NULL;
+    }
+    pcred = proc_ucred(pr);
+    cr.cr_ref = 1;
+    cr.cr_uid = pcred->cr_uid;
+    cr.cr_ngroups = pcred->cr_ngroups;
+    memcpy(cr.cr_groups, pcred->cr_groups,
+           NGROUPS * sizeof(gid_t));
+    return &cr;
+}
 #elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 const struct AFS_UCRED *
 afs_osi_proc2cred(AFS_PROC * pr)
index 2e2879d..b2ba0cc 100644 (file)
@@ -123,25 +123,25 @@ struct afs_osi_WaitHandle {
 /*
  * Vnode related macros
  */
-#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#if defined(AFS_DARWIN80_ENV)
+#define vType(vc)               vnode_vtype(AFSTOV(vc))
+#else
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #define vSetVfsp(vc, vfsp)      AFSTOV(vc)->v_mount = (vfsp)
 #define vSetType(vc, type)      AFSTOV(vc)->v_type = (type)
 #define vType(vc)               AFSTOV(vc)->v_type
-#else
-#define        vType(vc)           (vc)->v.v_type
-#define        vSetType(vc,type)   (vc)->v.v_type = (type)
-#define        vSetVfsp(vc,vfsp)   (vc)->v.v_vfsp = (vfsp)
-#endif
-
-#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 extern int (**afs_vnodeop_p) ();
 #define IsAfsVnode(v)      ((v)->v_op == afs_vnodeop_p)
 #define SetAfsVnode(v)     /* nothing; done in getnewvnode() */
 #else
+#define        vType(vc)           (vc)->v.v_type
+#define        vSetType(vc,type)   (vc)->v.v_type = (type)
+#define        vSetVfsp(vc,vfsp)   (vc)->v.v_vfsp = (vfsp)
 extern struct vnodeops *afs_ops;
 #define        IsAfsVnode(v)       ((v)->v_op == afs_ops)
 #define        SetAfsVnode(v)      (v)->v_op = afs_ops
 #endif
+#endif
 
 #ifdef AFS_SGI65_ENV
 #define        gop_lookupname(fnamep,segflg,followlink,compvpp) \
@@ -304,6 +304,18 @@ typedef struct timeval osi_timeval_t;
                AFS_GLOCK();                                    \
        } while(0)
 
+#if defined(AFS_DARWIN80_ENV)
+#define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                       \
+       do {                                                    \
+           int haveGlock = ISAFS_GLOCK();                      \
+           if (haveGlock)                                      \
+               AFS_GUNLOCK();                                  \
+           uio_setrw((UIO),(RW));                              \
+           CODE = uiomove((SRC),(LEN),(UIO));                  \
+           if (haveGlock)                                      \
+               AFS_GLOCK();                                    \
+       } while(0)
+#else
 #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                       \
        do {                                                    \
@@ -326,6 +338,7 @@ typedef struct timeval osi_timeval_t;
                AFS_GLOCK();                                    \
        } while(0)
 #endif
+#endif /* AFS_DARWIN80_ENV */
 
 #else /* AFS_GLOBAL_SUNLOCK */
 
@@ -344,6 +357,13 @@ typedef struct timeval osi_timeval_t;
            CODE = copyout((SRC),(DST),(LEN));                  \
        } while(0)
 
+#if defined(AFS_DARWIN80_ENV)
+#define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                       \
+       do {                                                    \
+           uio_setrw((UIO),(RW));                              \
+           CODE = uiomove((SRC),(LEN),(UIO));                  \
+       } while(0)
+#else /* AFS_OSF_ENV || AFS_FBSD_ENV */
 #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                       \
        do {                                                    \
@@ -356,9 +376,19 @@ typedef struct timeval osi_timeval_t;
            CODE = uiomove((SRC),(LEN),(RW),(UIO));             \
        } while(0)
 #endif /* AFS_OSF_ENV || AFS_FBSD_ENV */
+#endif /* AFS_DARWIN80_ENV */
 
 #endif /* AFS_GLOBAL_SUNLOCK */
 
+#ifdef AFS_DARWIN80_ENV
+#define AFS_UIO_OFFSET(uio) uio_offset(uio)
+#define AFS_UIO_RESID(uio) uio_resid(uio)
+#else
+#define AFS_UIO_OFFSET(uio) (uio)->uio_offset
+#define AFS_UIO_RESID(uio) (uio)->uio_resid
+#endif
+
+
 /*
  * encapsulation of kernel data structure accesses
  */
index eb51996..8c64aec 100644 (file)
@@ -241,6 +241,12 @@ afs_setpag(void)
        code = AddPag(genpag(), &credp);
        crfree(credp);
     }
+#elif defined(AFS_DARWIN80_ENV)
+    {
+       struct ucred *credp = kauth_cred_dup(proc_ucred(p));
+       code = AddPag(p, genpag(), &credp);
+       kauth_cred_rele(credp);
+    }
 #elif defined(AFS_DARWIN_ENV)
     {
        struct ucred *credp = crdup(p->p_cred->pc_ucred);
index b072dd5..8b55c0c 100644 (file)
@@ -25,6 +25,7 @@ RCSID
  * UIO routines
  */
 
+#ifndef AFS_DARWIN80_ENV
 /* routine to make copy of uio structure in ainuio, using aoutvec for space */
 int
 afsio_copy(struct uio *ainuio, struct uio *aoutuio,
@@ -76,6 +77,7 @@ afsio_trim(register struct uio *auio, register afs_int32 asize)
     }
     return 0;
 }
+#endif
 
 /* skip asize bytes in the current uio structure */
 int
@@ -85,6 +87,9 @@ afsio_skip(register struct uio *auio, register afs_int32 asize)
     register int cnt;
 
     AFS_STATCNT(afsio_skip);
+#ifdef AFS_DARWIN80_ENV
+    uio_update(auio, asize);
+#else
     /* It isn't guaranteed that multiple iovecs work ok (hasn't been tested!) */
     while (asize > 0 && auio->afsio_resid) {
        tv = auio->afsio_iov;
@@ -102,5 +107,6 @@ afsio_skip(register struct uio *auio, register afs_int32 asize)
        auio->uio_offset += cnt;
        asize -= cnt;
     }
+#endif
     return 0;
 }
index 40e0a9b..aea7f7a 100644 (file)
@@ -23,7 +23,7 @@ RCSID
 
 
 
-#if !defined(AFS_LINUX20_ENV)
+#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN80_ENV)
 /* This is the common part of the vget VFS call. */
 int
 afs_osi_vget(struct vcache **avcpp, struct fid *afidp, struct vrequest *areqp)
index 7f8b53c..ed0ff1d 100644 (file)
@@ -1139,24 +1139,43 @@ afsi_SetServerIPRank(struct srvAddr *sa, struct in_ifaddr *ifa)
 void
 afsi_SetServerIPRank(sa, ifa)
      struct srvAddr *sa;
+#ifdef AFS_DARWIN80_ENV
+     ifaddr_t ifa;
+#else
      struct ifaddr *ifa;
+#endif
 {
+    struct sockaddr sout;
     struct sockaddr_in *sin;
     int t;
 
     afs_uint32 subnetmask, myAddr, myNet, myDstaddr, mySubnet, netMask;
     afs_uint32 serverAddr;
 
-    if (ifa->ifa_addr->sa_family != AF_INET)
+    if (ifaddr_address_family(ifa) != AF_INET)
        return;
-    sin = (struct sockaddr_in *)ifa->ifa_addr;
-    myAddr = ntohl(sin->sin_addr.s_addr);      /* one of my IP addr in host order */
+    t = ifaddr_address(ifa, &sout, sizeof(sout));
+    if (t == 0) {
+       sin = (struct sockaddr_in *)&sout;
+       myAddr = ntohl(sin->sin_addr.s_addr);   /* one of my IP addr in host order */
+    } else {
+       myAddr = 0;
+    }
     serverAddr = ntohl(sa->sa_ip);     /* server's IP addr in host order */
-    sin = (struct sockaddr_in *)ifa->ifa_netmask;
-    subnetmask = ntohl(sin->sin_addr.s_addr);  /* subnet mask in host order */
-    sin = (struct sockaddr_in *)ifa->ifa_dstaddr;
-    if (sin)
+    t = ifaddr_netmask(ifa, &sout, sizeof(sout));
+    if (t == 0) {
+       sin = (struct sockaddr_in *)&sout;
+       subnetmask = ntohl(sin->sin_addr.s_addr);       /* subnet mask in host order */
+    } else {
+       subnetmask = 0;
+    }
+    t = ifaddr_dstaddress(ifa, &sout, sizeof(sout));
+    if (t == 0) {
+       sin = (struct sockaddr_in *)&sout;
        myDstaddr = sin->sin_addr.s_addr;
+    } else {
+       myDstaddr = 0;
+    }
 
     if (IN_CLASSA(myAddr))
        netMask = IN_CLASSA_NET;
@@ -1175,20 +1194,20 @@ afsi_SetServerIPRank(sa, ifa)
            if (serverAddr == myAddr) { /* same machine */
                sa->sa_iprank = afs_min(sa->sa_iprank, TOPR);
            } else {            /* same subnet */
-               sa->sa_iprank = afs_min(sa->sa_iprank, HI + ifa->ifa_metric);
+               sa->sa_iprank = afs_min(sa->sa_iprank, HI + ifnet_metric(ifaddr_ifnet(ifa)));
            }
        } else {                /* same net */
-           sa->sa_iprank = afs_min(sa->sa_iprank, MED + ifa->ifa_metric);
+           sa->sa_iprank = afs_min(sa->sa_iprank, MED + ifnet_metric(ifaddr_ifnet(ifa)));
        }
     }
 #ifdef  IFF_POINTTOPOINT
     /* check for case #4 -- point-to-point link */
-    if ((ifa->ia_ifp->if_flags & IFF_POINTOPOINT)
+    if ((ifnet_flags(ifaddr_ifnet(ifa)) & IFF_POINTOPOINT)
        && (myDstaddr == serverAddr)) {
-       if (ifa->ia_ifp->if_metric >= (MAXDEFRANK - MED) / PPWEIGHT)
+       if (ifnet_metric(ifaddr_ifnet(ifa)) >= (MAXDEFRANK - MED) / PPWEIGHT)
            t = MAXDEFRANK;
        else
-           t = MED + (PPWEIGHT << ifa->->ifa_metric);
+           t = MED + (PPWEIGHT << ifnet_metric(ifaddr_ifnet(ifa)));
        if (sa->sa_iprank > t)
            sa->sa_iprank = t;
        }
@@ -1361,6 +1380,20 @@ static int afs_SetServerPrefs(struct srvAddr *sa) {
 #ifdef AFS_SGI62_ENV
     (void)hash_enum(&hashinfo_inaddr, afsi_enum_set_rank, HTF_INET, NULL,
                    (caddr_t) sa, NULL);
+#elif defined(AFS_DARWIN80_ENV)
+    {
+       errno_t t;
+       int cnt=0;
+       ifaddr_t *addresses, address;
+       t = ifnet_get_address_list_family(NULL, &addresses, AF_INET);
+       if (t == 0) {
+           while(addresses[cnt] != NULL) {
+               afsi_SetServerIPRank(sa, address);
+               cnt++;
+           }
+           ifnet_free_address_list(addresses);
+       }
+    }
 #elif defined(AFS_DARWIN60_ENV)
     {
        struct ifnet *ifn;
index bdca1dc..cb13b38 100644 (file)
@@ -274,7 +274,7 @@ afs_CheckLocks(void)
                if (VREFCOUNT(tvc) > 1)
 #else /* AFS_OSF_ENV */
 #ifdef AFS_DARWIN80_ENV
-               if (vnode_isinuse(AFSTOV(tvc)))
+               if (vnode_isinuse(AFSTOV(tvc), 0))
 #else
                if (VREFCOUNT(tvc))
 #endif
index 5f6040d..70ff491 100644 (file)
@@ -232,7 +232,7 @@ afs_FlushVCache(struct vcache *avc, int *slept)
     afs_vcount--;
     vSetType(avc, VREG);
 #ifdef AFS_DARWIN80_ENV
-    if (vnode_isinuse(AFSTOV(avc))) {
+    if (vnode_isinuse(AFSTOV(avc), 0)) {
 #else
     if (VREFCOUNT(avc) > 0) {
 #endif
@@ -620,14 +620,14 @@ afs_NewVCache(struct VenusFid *afid, struct server *serverp)
            else if (QNext(uq) != tq)
                refpanic("VLRU inconsistent");
 #ifdef AFS_DARWIN80_ENV
-           else if (!vnode_isinuse(AFSTOV(tvc))) 
+           else if (!vnode_isinuse(AFSTOV(tvc), 0)) 
 #else
            else if (VREFCOUNT(tvc) < 1)
 #endif
                refpanic("refcnt 0 on VLRU");
 
 #ifdef AFS_DARWIN80_ENV
-           if (vnode_isinuse(AFSTOV(tvc)) &&  
+           if (vnode_isinuse(AFSTOV(tvc), 0) &&  
 #else
            if (VREFCOUNT(tvc) == 1 &&
 #endif
@@ -725,7 +725,7 @@ restart:
 #endif
 
 #ifdef AFS_DARWIN80_ENV
-           if (!vnode_isinuse(AFSTOV(tvc)
+           if (!vnode_isinuse(AFSTOV(tvc), 0
 #else
            if (((VREFCOUNT(tvc) == 0) 
 #if defined(AFS_DARWIN_ENV) && !defined(UKERNEL) 
index 443166b..2ab604c 100644 (file)
@@ -39,7 +39,7 @@
 #define AFSBIG_ENDIAN   1
 #define AFS_HAVE_FFS    1      /* Use system's ffs. */
 
-#define AFS_GCPAGS                1    /* if nonzero, garbage collect PAGs */
+#define AFS_GCPAGS               0
 #define RXK_LISTENER_ENV         1
 
 #ifdef KERNEL
 #define va_nodeid       va_fileid
 #define vfs_vnodecovered mnt_vnodecovered
 #define direct          dirent
-#define vnode_t         struct vnode
 
-//#define VN_RELE(vp)     vrele(((struct vnode *)(vp)))
-//#define VN_HOLD(vp)     VREF(((struct vnode *)(vp)))
 #define BIND_8_COMPAT
 
 #endif
index 20ecf6c..7bee813 100644 (file)
@@ -33,6 +33,8 @@ AFS_OS_NONFSOBJS = osi_vfsops.o
 KDEFS=
 DBUG = 
 DEFINES= -D_KERNEL -DKERNEL -DKERNEL_PRIVATE -DDIAGNOSTIC -DUSE_SELECT -DMACH_USER_API -DMACH_KERNEL
+<ppc_darwin_80>
+KOPTS=-static -g -nostdinc -nostdlib -no-cpp-precomp -fno-builtin -finline -fno-keep-inline-functions -msoft-float -fsigned-bitfields -arch ppc -Dppc -DPPC -D__PPC__ -DPAGE_SIZE_FIXED -O2 -mcpu=750 -mmultiple -fschedule-insns
 <ppc_darwin_70>
 KOPTS=-static -fno-common -finline -fno-keep-inline-functions -force_cpusubtype_ALL -msoft-float -mlong-branch 
 <ppc_darwin_60>