death-to-dux-client-20060802
authorRuss Allbery <rra@stanford.edu>
Wed, 2 Aug 2006 17:50:43 +0000 (17:50 +0000)
committerRuss Allbery <rra@stanford.edu>
Wed, 2 Aug 2006 17:50:43 +0000 (17:50 +0000)
Remove the DUX client files.  This code doesn't work on any current DUX
system.

14 files changed:
src/afs/DUX/osi_file.c [deleted file]
src/afs/DUX/osi_groups.c [deleted file]
src/afs/DUX/osi_inode.c [deleted file]
src/afs/DUX/osi_inode.h [deleted file]
src/afs/DUX/osi_machdep.h [deleted file]
src/afs/DUX/osi_misc.c [deleted file]
src/afs/DUX/osi_prototypes.h [deleted file]
src/afs/DUX/osi_sleep.c [deleted file]
src/afs/DUX/osi_vfsops.c [deleted file]
src/afs/DUX/osi_vm.c [deleted file]
src/afs/DUX/osi_vnodeops.c [deleted file]
src/rx/DUX/rx_kmutex.c [deleted file]
src/rx/DUX/rx_kmutex.h [deleted file]
src/rx/DUX/rx_knet.c [deleted file]

diff --git a/src/afs/DUX/osi_file.c b/src/afs/DUX/osi_file.c
deleted file mode 100644 (file)
index 450312e..0000000
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-#include <afsconfig.h>
-#include "afs/param.h"
-
-RCSID
-    ("$Header$");
-
-#include "afs/sysincludes.h"   /* Standard vendor system headers */
-#include "afsincludes.h"       /* Afs-based standard headers */
-#include "afs/afs_stats.h"     /* afs statistics */
-
-
-int afs_osicred_initialized = 0;
-struct AFS_UCRED afs_osi_cred;
-afs_lock_t afs_xosi;           /* lock is for tvattr */
-extern struct osi_dev cacheDev;
-extern struct mount *afs_cacheVfsp;
-
-
-void *
-osi_UFSOpen(afs_int32 ainode)
-{
-    static struct vnode *tags_vnode = NULL;
-    struct inode *ip;
-    register struct osi_file *afile = NULL;
-    extern int cacheDiskType;
-    afs_int32 code = 0;
-    int dummy;
-    AFS_STATCNT(osi_UFSOpen);
-    if (cacheDiskType != AFS_FCACHE_TYPE_UFS)
-       osi_Panic("UFSOpen called for non-UFS cache\n");
-
-    afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
-    AFS_GUNLOCK();
-
-    switch (afs_cacheVfsp->m_stat.f_type) {
-    case MOUNT_UFS:
-       code =
-           igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, (ino_t) ainode,
-                     &ip, &dummy);
-       if (code) {
-           osi_FreeSmallSpace(afile);
-           osi_Panic("UFSOpen: igetinode failed");
-       }
-       IN_UNLOCK(ip);
-       afile->vnode = ITOV(ip);
-       afile->size = VTOI(afile->vnode)->i_size;
-       afile->offset = 0;
-       afile->proc = NULL;
-       afile->inum = ainode;   /* for hint validity checking */
-       break;
-    case MOUNT_MSFS:{
-           char path[1024];
-           struct nameidata nd, *ndp = &nd;
-           struct utask_nd utnd = { NULL, NULL };
-           struct vattr attr;
-
-           memset(&nd, 0, sizeof(nd));
-           ndp->ni_utnd = &utnd;
-           ndp->ni_nameiop = LOOKUP;
-           ndp->ni_cred = &afs_osi_cred;
-           ndp->ni_segflg = UIO_SYSSPACE;
-
-           /* get hold of a vnode for the .tags directory, so we can
-            * lookup files relative to it */
-           if (tags_vnode == NULL) {
-               ndp->ni_cdir = afs_cacheVfsp->m_vnodecovered;
-               strcpy(path, afs_cacheVfsp->m_stat.f_mntonname);
-               strcat(path, "/.tags");
-               ndp->ni_dirp = path;
-               if ((code = namei(ndp)))
-                   osi_Panic("failed to lookup %s (%d)", path, code);
-               tags_vnode = ndp->ni_vp;
-           }
-           sprintf(path, "%d", ainode);
-           ndp->ni_dirp = path;
-           ndp->ni_cdir = tags_vnode;
-           if ((code = namei(ndp)))
-               osi_Panic("failed to lookup %s (%d)", path, code);
-
-           /* XXX this sucks, chances are we're going to do this again right
-            * away, but apparently we can't just set the size to 0 */
-           VOP_GETATTR(ndp->ni_vp, &attr, &afs_osi_cred, code);
-           if (code)
-               osi_Panic("failed to stat %s (%d)", path, code);
-
-           afile->vnode = ndp->ni_vp;
-           afile->size = attr.va_size;
-           afile->offset = 0;
-           afile->proc = NULL;
-           afile->inum = ainode;       /* for hint validity checking */
-           break;
-       }
-    default:
-       osi_Panic("UFSOpen called for unknown cache-type (%d)",
-                 afs_cacheVfsp->m_stat.f_type);
-    }
-
-    AFS_GLOCK();
-    return afile;
-}
-
-int
-afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat)
-{
-    register afs_int32 code;
-    struct vattr tvattr;
-    AFS_STATCNT(osi_Stat);
-    MObtainWriteLock(&afs_xosi, 320);
-    AFS_GUNLOCK();
-    VOP_GETATTR(afile->vnode, &tvattr, &afs_osi_cred, code);
-    AFS_GLOCK();
-    if (code == 0) {
-       astat->size = tvattr.va_size;
-       astat->blksize = tvattr.va_blocksize;
-       astat->mtime = tvattr.va_mtime.tv_sec;
-       astat->atime = tvattr.va_atime.tv_sec;
-    }
-    MReleaseWriteLock(&afs_xosi);
-    return code;
-}
-
-int
-osi_UFSClose(register struct osi_file *afile)
-{
-    AFS_STATCNT(osi_Close);
-    if (afile->vnode) {
-       AFS_RELE(afile->vnode);
-    }
-
-    osi_FreeSmallSpace(afile);
-    return 0;
-}
-
-int
-osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize)
-{
-    struct AFS_UCRED *oldCred;
-    struct vattr tvattr;
-    register afs_int32 code;
-    struct osi_stat tstat;
-    AFS_STATCNT(osi_Truncate);
-
-    /* This routine only shrinks files, and most systems
-     * have very slow truncates, even when the file is already
-     * small enough.  Check now and save some time.
-     */
-    code = afs_osi_Stat(afile, &tstat);
-    if (code || tstat.size <= asize)
-       return code;
-    MObtainWriteLock(&afs_xosi, 321);
-    VATTR_NULL(&tvattr);
-    /* note that this credential swapping stuff is only necessary because
-     * of ufs's references directly to u.u_cred instead of to
-     * credentials parameter.  Probably should fix ufs some day. */
-    oldCred = u.u_cred;                /* remember old credentials pointer  */
-    u.u_cred = &afs_osi_cred;  /* temporarily use superuser credentials */
-    tvattr.va_size = asize;
-    AFS_GUNLOCK();
-    VOP_SETATTR(afile->vnode, &tvattr, &afs_osi_cred, code);
-    AFS_GLOCK();
-    u.u_cred = oldCred;                /* restore */
-    MReleaseWriteLock(&afs_xosi);
-    return code;
-}
-
-void
-osi_DisableAtimes(struct vnode *avp)
-{
-    struct inode *ip;
-    assert(avp->v_tag == VT_UFS);
-    ip = VTOI(avp);
-    ip->i_flag &= ~IACC;
-}
-
-
-/* Generic read interface */
-int
-afs_osi_Read(register struct osi_file *afile, int offset, void *aptr,
-            afs_int32 asize)
-{
-    struct AFS_UCRED *oldCred;
-    unsigned int resid;
-    register afs_int32 code;
-    register afs_int32 cnt1 = 0;
-    AFS_STATCNT(osi_Read);
-
-    /**
-      * If the osi_file passed in is NULL, panic only if AFS is not shutting
-      * down. No point in crashing when we are already shutting down
-      */
-    if (!afile) {
-       if (!afs_shuttingdown)
-           osi_Panic("osi_Read called with null param");
-       else
-           return EIO;
-    }
-
-    if (offset != -1)
-       afile->offset = offset;
-    AFS_GUNLOCK();
-    code =
-       gop_rdwr(UIO_READ, afile->vnode, (caddr_t) aptr, asize, afile->offset,
-                AFS_UIOSYS, IO_UNIT, &afs_osi_cred, &resid);
-    AFS_GLOCK();
-    if (code == 0) {
-       code = asize - resid;
-       afile->offset += code;
-       osi_DisableAtimes(afile->vnode);
-    } else {
-       afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, resid,
-                  ICL_TYPE_INT32, code);
-       code = -1;
-    }
-    return code;
-}
-
-/* Generic write interface */
-int
-afs_osi_Write(register struct osi_file *afile, afs_int32 offset, void *aptr,
-             afs_int32 asize)
-{
-    struct AFS_UCRED *oldCred;
-    unsigned int resid;
-    register afs_int32 code;
-    AFS_STATCNT(osi_Write);
-    if (!afile)
-       osi_Panic("afs_osi_Write called with null param");
-    if (offset != -1)
-       afile->offset = offset;
-    {
-       struct ucred *tmpcred = u.u_cred;
-       u.u_cred = &afs_osi_cred;
-       AFS_GUNLOCK();
-       code =
-           gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize,
-                    afile->offset, AFS_UIOSYS, IO_UNIT, &afs_osi_cred,
-                    &resid);
-       AFS_GLOCK();
-       u.u_cred = tmpcred;
-    }
-    if (code == 0) {
-       code = asize - resid;
-       afile->offset += code;
-    } else {
-       code = -1;
-    }
-    if (afile->proc) {
-       (*afile->proc) (afile, code);
-    }
-    return code;
-}
-
-
-/*  This work should be handled by physstrat in ca/machdep.c.
-    This routine written from the RT NFS port strategy routine.
-    It has been generalized a bit, but should still be pretty clear. */
-int
-afs_osi_MapStrategy(int (*aproc) (), register struct buf *bp)
-{
-    afs_int32 returnCode;
-
-    AFS_STATCNT(osi_MapStrategy);
-    returnCode = (*aproc) (bp);
-
-    return returnCode;
-}
-
-
-
-void
-shutdown_osifile(void)
-{
-    extern int afs_cold_shutdown;
-
-    AFS_STATCNT(shutdown_osifile);
-    if (afs_cold_shutdown) {
-       afs_osicred_initialized = 0;
-    }
-}
diff --git a/src/afs/DUX/osi_groups.c b/src/afs/DUX/osi_groups.c
deleted file mode 100644 (file)
index daed60c..0000000
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * Implements:
- * Afs_xsetgroups (syscall)
- * setpag
- *
- */
-#include <afsconfig.h>
-#include "afs/param.h"
-
-RCSID
-    ("$Header$");
-
-#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);
-
-static int
-  afs_setgroups(struct proc *proc, struct ucred **cred, int ngroups,
-               gid_t * gidset, int change_parent);
-
-int
-Afs_xsetgroups(p, args, retval)
-     struct proc *p;
-     void *args;
-     int *retval;
-{
-    int code = 0;
-    struct vrequest treq;
-
-    AFS_STATCNT(afs_xsetgroups);
-    AFS_GLOCK();
-
-    code = afs_InitReq(&treq, u.u_cred);
-    AFS_GUNLOCK();
-    if (code)
-       return code;
-
-    code = setgroups(p, args, retval);
-    /* Note that if there is a pag already in the new groups we don't
-     * overwrite it with the old pag.
-     */
-    if (PagInCred(u.u_cred) == NOPAG) {
-       if (((treq.uid >> 24) & 0xff) == 'A') {
-           AFS_GLOCK();
-           /* we've already done a setpag, so now we redo it */
-           AddPag(p, treq.uid, &p->p_rcred);
-           AFS_GUNLOCK();
-       }
-    }
-    return code;
-}
-
-
-int
-setpag(proc, cred, pagvalue, newpag, change_parent)
-     struct proc *proc;
-     struct ucred **cred;
-     afs_uint32 pagvalue;
-     afs_uint32 *newpag;
-     afs_uint32 change_parent;
-{
-    gid_t gidset[NGROUPS];
-    int ngroups, code;
-    int j;
-
-    AFS_STATCNT(setpag);
-    ngroups = afs_getgroups(*cred, NGROUPS, gidset);
-    if (afs_get_pag_from_groups(gidset[0], gidset[1]) == NOPAG) {
-       /* We will have to shift grouplist to make room for pag */
-       if (ngroups + 2 > NGROUPS) {
-           return (E2BIG);
-       }
-       for (j = ngroups - 1; j >= 0; j--) {
-           gidset[j + 2] = gidset[j];
-       }
-       ngroups += 2;
-    }
-    *newpag = (pagvalue == -1 ? genpag() : pagvalue);
-    afs_get_groups_from_pag(*newpag, &gidset[0], &gidset[1]);
-    code = afs_setgroups(proc, cred, ngroups, gidset, change_parent);
-    return code;
-}
-
-
-static int
-afs_getgroups(struct ucred *cred, int ngroups, gid_t * gidset)
-{
-    int ngrps, savengrps;
-    gid_t *gp;
-
-    AFS_STATCNT(afs_getgroups);
-    savengrps = ngrps = MIN(ngroups, cred->cr_ngroups);
-    gp = cred->cr_groups;
-    while (ngrps--)
-       *gidset++ = *gp++;
-    return savengrps;
-}
-
-
-
-static int
-afs_setgroups(struct proc *proc, struct ucred **cred, int ngroups,
-             gid_t * gidset, int change_parent)
-{
-    int ngrps;
-    int i;
-    gid_t *gp;
-    struct ucred *newcr, *cr;
-
-    AFS_STATCNT(afs_setgroups);
-    /*
-     * The real setgroups() call does this, so maybe we should too.
-     *
-     */
-    if (ngroups > NGROUPS)
-       return EINVAL;
-    cr = *cred;
-    if (!change_parent) {
-       crhold(cr);
-       newcr = crcopy(cr);
-    } else
-       newcr = cr;
-    newcr->cr_ngroups = ngroups;
-    gp = newcr->cr_groups;
-    while (ngroups--)
-       *gp++ = *gidset++;
-    if (!change_parent) {
-       substitute_real_creds(proc, NOUID, NOUID, NOGID, NOGID, newcr);
-    }
-    *cred = newcr;
-    return (0);
-}
diff --git a/src/afs/DUX/osi_inode.c b/src/afs/DUX/osi_inode.c
deleted file mode 100644 (file)
index daab167..0000000
+++ /dev/null
@@ -1,334 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * DUX inode operations
- *
- * Implements:
- *
- */
-#include <afsconfig.h>
-#include "afs/param.h"
-
-RCSID
-    ("$Header$");
-
-#include "afs/sysincludes.h"   /* Standard vendor system headers */
-#include "afsincludes.h"       /* Afs-based standard headers */
-#include "afs/osi_inode.h"
-#include "afs/afs_stats.h"     /* statistics stuff */
-#include <ufs/ufsmount.h>
-
-/* given a vnode, return the `inode number'; if it's a UFS vnode just
-   return the i_number from the in kernel inode struct, if not stat
-   the file to get the inumber from there */
-afs_uint32
-osi_vnodeToInumber(struct vnode *vnode)
-{
-    int error;
-    struct vattr attr;
-
-    /* use faster version with UFS */
-    if (vnode->v_tag == VT_UFS)
-       return VTOI(vnode)->i_number;
-    /* otherwise stat the file */
-    VOP_GETATTR(vnode, &attr, NULL, error);
-    if (error)
-       osi_Panic("VOP_GETATTR = %d", error);
-    return attr.va_fileid;
-}
-
-/* return the id of the device containing the file */
-afs_uint32
-osi_vnodeToDev(struct vnode * vnode)
-{
-    int error;
-    struct vattr attr;
-
-    /* use faster version with UFS */
-    if (vnode->v_tag == VT_UFS)
-       return VTOI(vnode)->i_dev;
-    /* otherwise stat the file */
-    VOP_GETATTR(vnode, &attr, NULL, error);
-    if (error)
-       osi_Panic("VOP_GETATTR = %d", error);
-    return attr.va_rdev;
-}
-
-getinode(fs, dev, inode, ipp, perror)
-     struct mount *fs;
-     struct inode **ipp;
-     dev_t dev;
-     ino_t inode;
-     int *perror;
-{
-    register struct vnode *vp;
-    char fake_vnode[FAKE_INODE_SIZE];
-    struct inode *ip;
-    int code;
-
-    *ipp = 0;
-    *perror = 0;
-    if (!fs) {
-       register struct ufsmount *ump;
-       register struct vnode *vp;
-       register struct mount *mp;
-
-       MOUNTLIST_LOCK();
-       if (mp = rootfs)
-           do {
-               /*
-                * XXX Also do the test for MFS 
-                */
-#undef m_data
-#undef m_next
-               if (mp->m_stat.f_type == MOUNT_UFS) {
-                   MOUNTLIST_UNLOCK();
-                   ump = VFSTOUFS(mp);
-                   if (ump->um_fs == NULL)
-                       break;
-                   if (ump->um_dev == dev) {
-                       fs = ump->um_mountp;
-                   }
-                   MOUNTLIST_LOCK();
-               }
-#ifdef AFS_DUX50_ENV
-#define m_next m_nxt
-#endif
-               mp = mp->m_next;
-           } while (mp != rootfs);
-       MOUNTLIST_UNLOCK();
-       if (!fs)
-           return (ENXIO);
-    }
-    vp = (struct vnode *)fake_vnode;
-    fake_inode_init(vp, fs);
-    assert(vp->v_tag == VT_UFS);
-    code = iget(VTOI(vp), inode, &ip, 0);
-    if (code != 0) {
-       *perror = BAD_IGET;
-       return code;
-    } else {
-       *ipp = ip;
-       return (0);
-    }
-}
-
-igetinode(vfsp, dev, inode, ipp, perror)
-     struct inode **ipp;
-     struct mount *vfsp;
-     dev_t dev;
-     ino_t inode;
-     int *perror;
-{
-    struct inode *pip, *ip;
-    extern struct osi_dev cacheDev;
-    register int code = 0;
-
-    *perror = 0;
-
-    AFS_STATCNT(igetinode);
-
-    if ((code = getinode(vfsp, dev, inode, &ip, perror)) != 0) {
-       return (code);
-    }
-
-    if (ip->i_mode == 0) {
-       /* Not an allocated inode */
-       iforget(ip);
-       return (ENOENT);
-    }
-
-    if (ip->i_nlink == 0 || (ip->i_mode & IFMT) != IFREG) {
-       iput(ip);
-       return (ENOENT);
-    }
-
-    *ipp = ip;
-    return (0);
-}
-
-iforget(ip)
-     struct inode *ip;
-{
-    struct vnode *vp = ITOV(ip);
-
-    AFS_STATCNT(iforget);
-
-    VN_LOCK(vp);
-    /* this whole thing is too wierd.  Why??? XXX */
-    if (vp->v_usecount == 1) {
-       VN_UNLOCK(vp);
-       idrop(ip);
-    } else {
-       VN_UNLOCK(vp);
-    }
-}
-
-/*
- * icreate system call -- create an inode
- */
-afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, retval)
-     long *retval;
-     long dev, near_inode, param1, param2, param3, param4;
-{
-    int dummy, err = 0;
-    struct inode *ip, *newip;
-    register int code;
-    struct vnode *vp;
-
-    AFS_STATCNT(afs_syscall_icreate);
-
-    if (!afs_suser(NULL))
-       return (EPERM);
-
-    code = getinode(0, (dev_t) dev, 2, &ip, &dummy);
-    if (code) {
-       return (ENOENT);
-    }
-    code = ialloc(ip, (ino_t) near_inode, 0, &newip);
-    iput(ip);
-    if (code) {
-       return (code);
-    }
-    IN_LOCK(newip);
-    newip->i_flag |= IACC | IUPD | ICHG;
-
-    newip->i_nlink = 1;
-
-    newip->i_mode = IFREG;
-
-    IN_UNLOCK(newip);
-    vp = ITOV(newip);
-    VN_LOCK(vp);
-    vp->v_type = VREG;
-    VN_UNLOCK(vp);
-
-    if (!vp->v_object) {
-       extern struct vfs_ubcops ufs_ubcops;
-       extern struct vm_ubc_object *ubc_object_allocate();
-       struct vm_ubc_object *vop;
-       vop = ubc_object_allocate(&vp, &ufs_ubcops, vp->v_mount->m_funnel);
-       VN_LOCK(vp);
-       vp->v_object = vop;
-       VN_UNLOCK(vp);
-    }
-
-
-    IN_LOCK(newip);
-    newip->i_flags |= IC_XUID | IC_XGID;
-    newip->i_flags &= ~IC_PROPLIST;
-    newip->i_vicep1 = param1;
-    if (param2 == 0x1fffffff /*INODESPECIAL*/) {
-       newip->i_vicep2 = ((0x1fffffff << 3) + (param4 & 0x3));
-       newip->i_vicep3a = (u_short) (param3 >> 16);
-       newip->i_vicep3b = (u_short) param3;
-    } else {
-       newip->i_vicep2 =
-           (((param2 >> 16) & 0x1f) << 27) +
-           (((param4 >> 16) & 0x1f) << 22) + (param3 & 0x3fffff);
-       newip->i_vicep3a = (u_short) param4;
-       newip->i_vicep3b = (u_short) param2;
-    }
-    newip->i_vicemagic = VICEMAGIC;
-
-    *retval = newip->i_number;
-    IN_UNLOCK(newip);
-    iput(newip);
-    return (code);
-}
-
-
-afs_syscall_iopen(dev, inode, usrmod, retval)
-     long *retval;
-     int dev, inode, usrmod;
-{
-    struct file *fp;
-    struct inode *ip;
-    struct vnode *vp = NULL;
-    int dummy;
-    int fd;
-    extern struct fileops vnops;
-    register int code;
-#ifdef AFS_DUX50_ENV
-    struct ufile_entry *fe;
-#endif
-
-    AFS_STATCNT(afs_syscall_iopen);
-
-    if (!afs_suser(NULL))
-       return (EPERM);
-
-    code = igetinode(0, (dev_t) dev, (ino_t) inode, &ip, &dummy);
-    if (code) {
-       return (code);
-    }
-#ifdef AFS_DUX50_ENV
-    if ((code = falloc(&fp, &fd, &fe)) != 0) {
-       iput(ip);
-       return (code);
-    }
-#else
-    if ((code = falloc(&fp, &fd)) != 0) {
-       iput(ip);
-       return (code);
-    }
-#endif
-    IN_UNLOCK(ip);
-
-    FP_LOCK(fp);
-    fp->f_flag = (usrmod - FOPEN) & FMASK;
-    fp->f_type = DTYPE_VNODE;
-    fp->f_ops = &vnops;
-    fp->f_data = (caddr_t) ITOV(ip);
-
-    FP_UNLOCK(fp);
-#ifdef AFS_DUX50_ENV
-    u_set_fe(fd, fe, fp, &u.u_file_state);
-#else
-    U_FD_SET(fd, fp, &u.u_file_state);
-#endif
-    *retval = fd;
-    return (0);
-}
-
-
-/*
- * Support for iinc() and idec() system calls--increment or decrement
- * count on inode.
- * Restricted to super user.
- * Only VICEMAGIC type inodes.
- */
-afs_syscall_iincdec(dev, inode, inode_p1, amount)
-     int dev, inode, inode_p1, amount;
-{
-    int dummy;
-    struct inode *ip;
-    register int code;
-
-    if (!afs_suser(NULL))
-       return (EPERM);
-
-    code = igetinode(0, (dev_t) dev, (ino_t) inode, &ip, &dummy);
-    if (code) {
-       return (code);
-    }
-    if (!IS_VICEMAGIC(ip)) {
-       return (EPERM);
-    } else if (ip->i_vicep1 != inode_p1) {
-       return (ENXIO);
-    }
-    ip->i_nlink += amount;
-    if (ip->i_nlink == 0) {
-       CLEAR_VICEMAGIC(ip);
-    }
-    ip->i_flag |= ICHG;
-    iput(ip);
-    return (0);
-}
diff --git a/src/afs/DUX/osi_inode.h b/src/afs/DUX/osi_inode.h
deleted file mode 100644 (file)
index 5055282..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * Inode information required for DUX servers and salvager.
- */
-#ifndef _OSI_INODE_H_
-#define _OSI_INODE_H_
-
-#define BAD_IGET       -1000
-
-#define VICEMAGIC       0xb61cfa84
-
-#define DI_VICEP3(p) \
-       ( ((u_int)((p)->di_vicep3a)) << 16 | ((u_int)((p)->di_vicep3b)) )
-#define I_VICE3(p) \
-       ( ((u_int)((p)->i_vicep3a)) << 16 | ((u_int)((p)->i_vicep3b)) )
-
-#define i_vicemagic    i_din.di_proplb
-#define i_vicep1       i_din.di_uid
-#define i_vicep2       i_din.di_gid
-#define i_vicep3a      i_din.di_bcuid
-#define i_vicep3b      i_din.di_bcgid
-#define i_vicep4       i_din.di_spare[0]       /* not used */
-
-#define di_vicemagic   di_proplb
-#define di_vicep1      di_uid
-#define di_vicep2      di_gid
-#define di_vicep3a     di_bcuid
-#define di_vicep3b     di_bcgid
-#define di_vicep4      di_spare[0]     /* not used */
-
-#define  IS_VICEMAGIC(ip)        ((ip)->i_vicemagic == VICEMAGIC)
-#define  IS_DVICEMAGIC(dp)       ((dp)->di_vicemagic == VICEMAGIC)
-
-#define  CLEAR_VICEMAGIC(ip)     (ip)->i_vicemagic = 0
-#define  CLEAR_DVICEMAGIC(dp)    (dp)->di_vicemagic = 0
-
-#endif /* _OSI_INODE_H_ */
diff --git a/src/afs/DUX/osi_machdep.h b/src/afs/DUX/osi_machdep.h
deleted file mode 100644 (file)
index b83f01f..0000000
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * DUX OSI header file. Extends afs_osi.h.
- *
- * afs_osi.h includes this file, which is the only way this file should
- * be included in a source file. This file can redefine macros declared in
- * afs_osi.h.
- */
-
-#ifndef _OSI_MACHDEP_H_
-#define _OSI_MACHDEP_H_
-
-#include <kern/lock.h>
-#include <kern/sched_prim.h>
-#include <sys/unix_defs.h>
-
-#define getpid()               u.u_procp->p_pid
-
-/* 
- * Time related macros
- */
-extern struct timeval time;
-#define osi_Time() (time.tv_sec)
-#define        afs_hz      hz
-
-#define PAGESIZE 8192
-
-#define        AFS_UCRED       ucred
-#define        AFS_PROC        struct proc
-
-#define afs_bufferpages bufpages
-
-#define osi_vnhold(avc,r)  do { \
-       if ((avc)->vrefCount) { VN_HOLD(AFSTOV(avc)); } \
-       else osi_Panic("refcnt==0");  } while(0)
-
-#define        gop_rdwr(rw,gp,base,len,offset,segflg,unit,cred,aresid) \
-  vn_rdwr((rw),(gp),(base),(len),(offset),(segflg),(unit),(cred),(aresid))
-
-#undef afs_suser
-
-#ifdef KERNEL
-extern simple_lock_data_t afs_global_lock;
-extern thread_t afs_global_owner;
-#define AFS_GLOCK() \
-    do { \
-       usimple_lock(&afs_global_lock); \
-       osi_Assert(afs_global_owner == (thread_t)0); \
-       afs_global_owner = current_thread(); \
-    } while (0)
-#define AFS_GUNLOCK() \
-    do { \
-       osi_Assert(afs_global_owner == current_thread()); \
-       afs_global_owner = (thread_t)0; \
-       usimple_unlock(&afs_global_lock); \
-    } while(0)
-#define ISAFS_GLOCK() (afs_global_owner == current_thread())
-
-#undef SPLVAR
-#define SPLVAR
-#undef NETPRI
-#define NETPRI
-#undef USERPRI
-#define USERPRI
-#endif /* KERNEL */
-
-#endif /* _OSI_MACHDEP_H_ */
diff --git a/src/afs/DUX/osi_misc.c b/src/afs/DUX/osi_misc.c
deleted file mode 100644 (file)
index 27f2b6b..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * Implements:
- * afs_suser
- */
-
-#include <afsconfig.h>
-#include "afs/param.h"
-
-RCSID
-    ("$Header$");
-
-#include "afs/sysincludes.h"   /* Standard vendor system headers */
-#include "afsincludes.h"       /* Afs-based standard headers */
-
-/*
- * afs_suser() returns true if the caller is superuser, false otherwise.
- *
- * Note that it must NOT set errno.
- */
-
-afs_suser(void *credp)
-{
-    int error;
-
-    if ((error = suser(u.u_cred, &u.u_acflag)) == 0) {
-       return (1);
-    }
-    return (0);
-}
diff --git a/src/afs/DUX/osi_prototypes.h b/src/afs/DUX/osi_prototypes.h
deleted file mode 100644 (file)
index 4bc45e9..0000000
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * osi_prototypes.h
- *
- * Exported macos support routines.
- */
-#ifndef _OSI_PROTO_H_
-#define _OSI_PROTO_H_
-
-/* osi_file.c */
-extern afs_rwlock_t afs_xosi;
-
-#endif /* _OSI_PROTO_H_ */
diff --git a/src/afs/DUX/osi_sleep.c b/src/afs/DUX/osi_sleep.c
deleted file mode 100644 (file)
index 12fa802..0000000
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-#include <afsconfig.h>
-#include "afs/param.h"
-
-RCSID
-    ("$Header$");
-
-#include "afs/sysincludes.h"   /* Standard vendor system headers */
-#include "afsincludes.h"       /* Afs-based standard headers */
-#include "afs/afs_stats.h"     /* afs statistics */
-
-
-
-static int osi_TimedSleep(char *event, afs_int32 ams, int aintok);
-
-static char waitV;
-
-
-void
-afs_osi_InitWaitHandle(struct afs_osi_WaitHandle *achandle)
-{
-    AFS_STATCNT(osi_InitWaitHandle);
-    achandle->proc = (caddr_t) 0;
-}
-
-/* cancel osi_Wait */
-void
-afs_osi_CancelWait(struct afs_osi_WaitHandle *achandle)
-{
-    caddr_t proc;
-
-    AFS_STATCNT(osi_CancelWait);
-    proc = achandle->proc;
-    if (proc == 0)
-       return;
-    achandle->proc = (caddr_t) 0;      /* so dude can figure out he was signalled */
-    afs_osi_Wakeup(&waitV);
-}
-
-/* afs_osi_Wait
- * Waits for data on ahandle, or ams ms later.  ahandle may be null.
- * Returns 0 if timeout and EINTR if signalled.
- */
-int
-afs_osi_Wait(afs_int32 ams, struct afs_osi_WaitHandle *ahandle, int aintok)
-{
-    int code;
-    afs_int32 endTime, tid;
-
-    AFS_STATCNT(osi_Wait);
-    endTime = osi_Time() + (ams / 1000);
-    if (ahandle)
-       ahandle->proc = (caddr_t) u.u_procp;
-    do {
-       AFS_ASSERT_GLOCK();
-       code = 0;
-       code = osi_TimedSleep(&waitV, ams, aintok);
-
-       if (code)
-           break;              /* if something happened, quit now */
-       /* if we we're cancelled, quit now */
-       if (ahandle && (ahandle->proc == (caddr_t) 0)) {
-           /* we've been signalled */
-           break;
-       }
-    } while (osi_Time() < endTime);
-    return code;
-}
-
-
-
-
-typedef struct afs_event {
-    struct afs_event *next;    /* next in hash chain */
-    char *event;               /* lwp event: an address */
-    int refcount;              /* Is it in use? */
-    int seq;                   /* Sequence number: this is incremented
-                                * by wakeup calls; wait will not return until
-                                * it changes */
-    int cond;
-} afs_event_t;
-
-#define HASHSIZE 128
-afs_event_t *afs_evhasht[HASHSIZE];    /* Hash table for events */
-#define afs_evhash(event)      (afs_uint32) ((((long)event)>>2) & (HASHSIZE-1));
-int afs_evhashcnt = 0;
-
-/* Get and initialize event structure corresponding to lwp event (i.e. address)
- * */
-static afs_event_t *
-afs_getevent(char *event)
-{
-    afs_event_t *evp, *newp = 0;
-    int hashcode;
-
-    AFS_ASSERT_GLOCK();
-    hashcode = afs_evhash(event);
-    evp = afs_evhasht[hashcode];
-    while (evp) {
-       if (evp->event == event) {
-           evp->refcount++;
-           return evp;
-       }
-       if (evp->refcount == 0)
-           newp = evp;
-       evp = evp->next;
-    }
-    if (!newp) {
-       newp = (afs_event_t *) osi_AllocSmallSpace(sizeof(afs_event_t));
-       afs_evhashcnt++;
-       newp->next = afs_evhasht[hashcode];
-       afs_evhasht[hashcode] = newp;
-       newp->seq = 0;
-    }
-    newp->event = event;
-    newp->refcount = 1;
-    return newp;
-}
-
-/* Release the specified event */
-#define relevent(evp) ((evp)->refcount--)
-
-
-void
-afs_osi_Sleep(void *event)
-{
-    struct afs_event *evp;
-    int seq;
-
-    evp = afs_getevent(event);
-    seq = evp->seq;
-    while (seq == evp->seq) {
-       AFS_ASSERT_GLOCK();
-       assert_wait((vm_offset_t) (&evp->cond), 0);
-       AFS_GUNLOCK();
-       thread_block();
-       AFS_GLOCK();
-    }
-    relevent(evp);
-}
-
-int
-afs_osi_SleepSig(void *event)
-{
-    afs_osi_Sleep(event);
-    return 0;
-}
-
-/* osi_TimedSleep
- * 
- * Arguments:
- * event - event to sleep on
- * ams --- max sleep time in milliseconds
- * aintok - 1 if should sleep interruptibly
- *
- * Returns 0 if timeout and EINTR if signalled.
- */
-static int
-osi_TimedSleep(char *event, afs_int32 ams, int aintok)
-{
-    int code = 0;
-    struct afs_event *evp;
-    int ticks;
-
-    ticks = (ams * afs_hz) / 1000;
-
-
-    evp = afs_getevent(event);
-
-    assert_wait((vm_offset_t) (&evp->cond), aintok);
-    AFS_GUNLOCK();
-    thread_set_timeout(ticks);
-    thread_block();
-    AFS_GLOCK();
-    if (current_thread()->wait_result != THREAD_AWAKENED)
-       code = EINTR;
-
-    relevent(evp);
-    return code;
-}
-
-
-int
-afs_osi_Wakeup(void *event)
-{
-    int ret = 1;
-    struct afs_event *evp;
-
-    evp = afs_getevent(event);
-    if (evp->refcount > 1) {
-       evp->seq++;
-       thread_wakeup((vm_offset_t) (&evp->cond));
-       ret = 0;
-    }
-    relevent(evp);
-    return ret;
-}
diff --git a/src/afs/DUX/osi_vfsops.c b/src/afs/DUX/osi_vfsops.c
deleted file mode 100644 (file)
index a70d2c9..0000000
+++ /dev/null
@@ -1,519 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * osi_vfsops.c for DUX
- */
-#include <afsconfig.h>
-#include "afs/param.h"
-
-RCSID
-    ("$Header$");
-
-#include "afs/sysincludes.h"   /* Standard vendor system headers */
-#include "afsincludes.h"       /* Afs-based standard headers */
-#include "afs/afs_stats.h"     /* statistics stuff */
-#include <sys/types.h>
-#include <kern/mach_param.h>
-#include <sys/sysconfig.h>
-#include <sys/systm.h>
-#include <sys/resource.h>
-#include <sys/errno.h>
-#include <sys/conf.h>
-#include <machine/machlimits.h>
-
-
-struct vcache *afs_globalVp = 0;
-struct mount *afs_globalVFS = 0;
-
-static u_char afs_mntid;
-int afs_vfsdev = 0;
-udecl_simple_lock_data(, afsmntid_lock)
-#define AFSMNTID_LOCK()         usimple_lock(&afsmntid_lock)
-#define AFSMNTID_UNLOCK()       usimple_unlock(&afsmntid_lock)
-#define AFSMNTID_LOCK_INIT()    usimple_lock_init(&afsmntid_lock)
-     int mp_afs_mount(struct mount *afsp, char *path, caddr_t data,
-                     struct nameidata *ndp)
-{
-    u_int size;
-
-    fsid_t tfsid;
-    struct mount *xmp, *getvfs();
-    int code;
-
-    AFS_GLOCK();
-    AFS_STATCNT(afs_mount);
-
-    if (afs_globalVFS) {       /* Don't allow remounts. */
-       AFS_GUNLOCK();
-       return (EBUSY);
-    }
-
-    afs_globalVFS = afsp;
-    afsp->vfs_bsize = 8192;
-/*
- * Generate a unique afs mount i.d. ( see nfs_mount() ).
- */
-    afsp->m_stat.f_fsid.val[0] = makedev(130, 0);
-    afsp->m_stat.f_fsid.val[1] = MOUNT_AFS;
-    AFSMNTID_LOCK();
-    if (++afs_mntid == 0)
-       ++afs_mntid;
-    AFSMNTID_UNLOCK();
-    BM(AFSMNTID_LOCK());
-    tfsid.val[0] = makedev(130, afs_mntid);
-    tfsid.val[1] = MOUNT_AFS;
-    BM(AFSMNTID_UNLOCK());
-
-    while (xmp = getvfs(&tfsid)) {
-       UNMOUNT_READ_UNLOCK(xmp);
-       tfsid.val[0]++;
-       AFSMNTID_LOCK();
-       afs_mntid++;
-       AFSMNTID_UNLOCK();
-    }
-    if (major(tfsid.val[0]) != 130) {
-       AFS_GUNLOCK();
-       return (ENOENT);
-    }
-    afsp->m_stat.f_fsid.val[0] = tfsid.val[0];
-
-    afsp->m_stat.f_mntonname = AFS_KALLOC(MNAMELEN);
-    afsp->m_stat.f_mntfromname = AFS_KALLOC(MNAMELEN);
-    if (!afsp->m_stat.f_mntonname || !afsp->m_stat.f_mntfromname)
-       panic("malloc failure in afs_mount\n");
-
-    memset(afsp->m_stat.f_mntonname, 0, MNAMELEN);
-    memset(afsp->m_stat.f_mntfromname, 0, MNAMELEN);
-    AFS_COPYINSTR(path, (caddr_t) afsp->m_stat.f_mntonname, MNAMELEN, &size,
-                 code);
-    memcpy(afsp->m_stat.f_mntfromname, "AFS", 4);
-    AFS_GUNLOCK();
-    (void)mp_afs_statfs(afsp);
-    AFS_GLOCK();
-    afs_vfsdev = afsp->m_stat.f_fsid.val[0];
-
-#ifndef        AFS_NONFSTRANS
-    /* Set up the xlator in case it wasn't done elsewhere */
-    afs_xlatorinit_v2();
-    afs_xlatorinit_v3();
-#endif
-    AFS_GUNLOCK();
-    return 0;
-}
-
-
-int
-mp_afs_unmount(struct mount *afsp, int flag)
-{
-    AFS_GLOCK();
-    AFS_STATCNT(afs_unmount);
-    afs_globalVFS = 0;
-    afs_shutdown();
-    AFS_GUNLOCK();
-    return 0;
-}
-
-
-int
-mp_afs_start(struct mount *mp, int flags)
-{
-    return (0);
-}
-
-int
-mp_afs_root(struct mount *afsp, struct vnode **avpp)
-{
-    register afs_int32 code = 0;
-    struct vrequest treq;
-    register struct vcache *tvp = 0;
-
-    AFS_GLOCK();
-    AFS_STATCNT(afs_root);
-    if (afs_globalVp && (afs_globalVp->states & CStatd)) {
-       tvp = afs_globalVp;
-    } else {
-       if (afs_globalVp) {
-           afs_PutVCache(afs_globalVp);
-           afs_globalVp = NULL;
-       }
-
-       if (!(code = afs_InitReq(&treq, u.u_cred))
-           && !(code = afs_CheckInit())) {
-           tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);
-           /* we really want this to stay around */
-           if (tvp) {
-               afs_globalVp = tvp;
-           } else
-               code = ENOENT;
-       }
-    }
-    if (tvp) {
-       struct vnode *vp = AFSTOV(tvp);
-       AFS_GUNLOCK();
-       VN_HOLD(vp);
-       VN_LOCK(vp);
-       vp->v_flag |= VROOT;    /* No-op on Ultrix 2.2 */
-       VN_UNLOCK(vp);
-       AFS_GLOCK();
-
-       afs_globalVFS = afsp;
-       *avpp = vp;
-    }
-
-    afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *avpp,
-              ICL_TYPE_INT32, code);
-    AFS_GUNLOCK();
-    return code;
-}
-
-
-mp_afs_quotactl(struct mount * mp, int cmd, uid_t uid, caddr_t arg)
-{
-    return EOPNOTSUPP;
-}
-
-int
-mp_afs_statfs(struct mount *afsp)
-{
-    struct nstatfs *abp = &afsp->m_stat;
-
-    AFS_GLOCK();
-    AFS_STATCNT(afs_statfs);
-
-    abp->f_type = MOUNT_AFS;
-    abp->f_bsize = afsp->vfs_bsize;
-
-    /* Fake a high number below to satisfy programs that use the statfs call
-     * to make sure that there's enough space in the device partition before
-     * storing something there.
-     */
-    abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
-       abp->f_ffree = 2000000;
-    abp->f_fsize = 1024;
-
-    abp->f_fsid.val[0] = afsp->m_stat.f_fsid.val[0];
-    abp->f_fsid.val[1] = afsp->m_stat.f_fsid.val[1];
-
-    AFS_GUNLOCK();
-    return 0;
-}
-
-
-int
-mp_afs_sync(struct mount *mp, int flags)
-{
-    AFS_STATCNT(afs_sync);
-    return 0;
-}
-
-
-#ifdef AFS_DUX50_ENV
-int
-mp_afs_smoothsync(struct mount *mp, u_int age, u_int smsync_flag)
-{
-    AFS_STATCNT(afs_sync);
-    return 0;
-}
-#endif
-
-int
-mp_afs_fhtovp(struct mount *afsp, struct fid *fidp, struct vnode **avcp)
-{
-    struct vrequest treq;
-    register code = 0;
-
-    AFS_GLOCK();
-    AFS_STATCNT(afs_vget);
-
-    *avcp = NULL;
-
-    if ((code = afs_InitReq(&treq, u.u_cred)) == 0) {
-       code = afs_osi_vget((struct vcache **)avcp, fidp, &treq);
-    }
-
-    afs_Trace3(afs_iclSetp, CM_TRACE_VGET, ICL_TYPE_POINTER, *avcp,
-              ICL_TYPE_INT32, treq.uid, ICL_TYPE_FID, fidp);
-
-    code = afs_CheckCode(code, &treq, 42);
-    AFS_GUNLOCK();
-    return code;
-}
-
-
-/*
- *  afs_vptofh
- * 
- * afs_vptofh can return two flavors of NFS fid, depending on if submounts are
- * allowed. The reason for this is that we can't guarantee that we found all 
- * the entry points any OS might use to get the fid for the NFS mountd.
- * Hence we return a "magic" fid for all but /afs. If it goes through the
- * translator code, it will get transformed into a SmallFid that we recognize.
- * So, if submounts are disallowed, and an NFS client tries a submount, it will
- * get a fid which we don't recognize and the mount will either fail or we
- * will ignore subsequent requests for that mount.
- *
- * The Alpha fid is organized differently than for other platforms. Their
- * intention was to have the data portion of the fid aligned on a 4 byte
- * boundary. To do so, the fid is organized as:
- * u_short reserved
- * u_short len
- * char data[8]
- * The len field is the length of the entire fid, from reserved through data.
- * This length is used by fid_copy to include copying the reserved field. 
- * Alpha's zero the reserved field before handing us the fid, but they use
- * it in fid_cmp. We use the reserved field to store the 16 bits of the Vnode.
- *
- * Note that the SmallFid only allows for 8 bits of the cell index and
- * 16 bits of the vnode. 
- */
-
-#define AFS_FIDDATASIZE 8
-#define AFS_SIZEOFSMALLFID 12  /* full size of fid, including len field */
-extern int afs_NFSRootOnly;    /* 1 => only allow NFS mounts of /afs. */
-int afs_fid_vnodeoverflow = 0, afs_fid_uniqueoverflow = 0;
-
-int
-mp_afs_vptofh(struct vnode *avn, struct fid *fidp)
-{
-    struct SmallFid Sfid;
-    long addr[2];
-    register struct cell *tcell;
-    int rootvp = 0;
-    struct vcache *avc = VTOAFS(avn);
-
-    AFS_GLOCK();
-    AFS_STATCNT(afs_fid);
-
-    if (afs_shuttingdown) {
-       AFS_GUNLOCK();
-       return EIO;
-    }
-
-    if (afs_NFSRootOnly && (avc == afs_globalVp))
-       rootvp = 1;
-    if (!afs_NFSRootOnly || rootvp) {
-       tcell = afs_GetCell(avc->fid.Cell, READ_LOCK);
-       Sfid.Volume = avc->fid.Fid.Volume;
-       fidp->fid_reserved = avc->fid.Fid.Vnode;
-       Sfid.CellAndUnique =
-           ((tcell->cellIndex << 24) + (avc->fid.Fid.Unique & 0xffffff));
-       afs_PutCell(tcell, READ_LOCK);
-       if (avc->fid.Fid.Vnode > 0xffff)
-           afs_fid_vnodeoverflow++;
-       if (avc->fid.Fid.Unique > 0xffffff)
-           afs_fid_uniqueoverflow++;
-    } else {
-       fidp->fid_reserved = AFS_XLATOR_MAGIC;
-       addr[0] = (long)avc;
-       AFS_GUNLOCK();
-       VN_HOLD(AFSTOV(avc));
-       AFS_GLOCK();
-    }
-
-    /* Use the fid pointer passed to us. */
-    fidp->fid_len = AFS_SIZEOFSMALLFID;
-    if (afs_NFSRootOnly) {
-       if (rootvp) {
-           memcpy(fidp->fid_data, (caddr_t) & Sfid, AFS_FIDDATASIZE);
-       } else {
-           memcpy(fidp->fid_data, (caddr_t) addr, AFS_FIDDATASIZE);
-       }
-    } else {
-       memcpy(fidp->fid_data, (caddr_t) & Sfid, AFS_FIDDATASIZE);
-    }
-    AFS_GUNLOCK();
-    return 0;
-}
-
-
-int mp_Afs_init(void);         /* vfs_init - defined below */
-
-
-/* This is only called by vfs_mount when afs is going to be mounted as root.
- * Since we don't support diskless clients we shouldn't come here.
- */
-int afsmountroot = 0;
-int
-mp_afs_mountroot(struct mount *afsp, struct vnode **vp)
-{
-    AFS_GLOCK();
-    AFS_STATCNT(afs_mountroot);
-    afsmountroot++;
-    AFS_GUNLOCK();
-    return EINVAL;
-}
-
-
-/* It's called to setup swapping over the net for diskless clients; again
- * not for us.
- */
-int afsswapvp = 0;
-int
-mp_afs_swapvp(void)
-{
-    AFS_GLOCK();
-    AFS_STATCNT(afs_swapvp);
-    afsswapvp++;
-    AFS_GUNLOCK();
-    return EINVAL;
-}
-
-
-struct vfsops afs_vfsops = {
-    mp_afs_mount,
-    mp_afs_start,
-    mp_afs_unmount,
-    mp_afs_root,
-    mp_afs_quotactl,
-    mp_afs_statfs,
-    mp_afs_sync,
-    mp_afs_fhtovp,             /* afs_vget */
-    mp_afs_vptofh,
-    mp_Afs_init,
-    mp_afs_mountroot,
-    mp_afs_swapvp,
-#ifdef AFS_DUX50_ENV
-    mp_afs_smoothsync
-#endif
-};
-
-
-/*
- * System Call Entry Points
- */
-#define NULL_FUNC          (int (*)(int))0
-
-int (*afs_syscall_func) () = NULL_FUNC;
-int (*afs_xsetgroups_func) () = NULL_FUNC;
-int (*afs_xioctl_func) () = NULL_FUNC;
-
-afssyscall(p, args, retval)
-     struct proc *p;
-     void *args;
-     long *retval;
-{
-    int (*func) ();
-    int code;
-
-    AFS_GLOCK();
-    func = afs_syscall_func;
-    if (func == NULL_FUNC) {
-       code = nosys(p, args, retval);
-    } else {
-       code = (*func) (p, args, retval);
-    }
-    AFS_GUNLOCK();
-    return code;
-}
-
-afsxsetgroups(p, args, retval)
-     struct proc *p;
-     void *args;
-     long *retval;
-{
-    int (*func) ();
-    int code;
-
-    AFS_GLOCK();
-    func = afs_xsetgroups_func;
-    if (func == NULL_FUNC) {
-       code = nosys(p, args, retval);
-    } else {
-       code = (*func) (p, args, retval);
-    }
-    AFS_GUNLOCK();
-    return code;
-}
-
-afsxioctl(p, args, retval)
-     struct proc *p;
-     void *args;
-     long *retval;
-{
-    int (*func) ();
-    int code;
-
-    AFS_GLOCK();
-    func = afs_xioctl_func;
-    if (func == NULL_FUNC) {
-       code = nosys(p, args, retval);
-    } else {
-       code = (*func) (p, args, retval);
-    }
-    AFS_GUNLOCK();
-    return code;
-}
-
-
-/*
- * VFS initialization and unload
- */
-
-afs_unconfig()
-{
-    return EBUSY;
-}
-
-
-cfg_subsys_attr_t afs_attributes[] = {
-    {"", 0, 0, 0, 0, 0, 0}     /* must be the last element */
-};
-
-afs_configure(cfg_op_t op, caddr_t indata, size_t indata_size,
-             caddr_t outdata, size_t outdata_size)
-{
-    cfg_attr_t *attributes;
-    int ret = ESUCCESS;
-    int i, j, size;
-    caddr_t p;
-
-    switch (op) {
-    case CFG_OP_CONFIGURE:
-       /*
-        * The indata parameter is a list of attributes to be configured, and 
-        * indata_size is the count of attributes.
-        */
-       if ((ret = vfssw_add_fsname(MOUNT_AFS, &afs_vfsops, "afs")) != 0)
-           return (ret);
-       break;
-    case CFG_OP_UNCONFIGURE:
-       if ((ret = afs_unconfig()) != 0)
-           return (ret);
-       break;
-    default:
-       ret = EINVAL;
-       break;
-    }
-    return ret;
-}
-
-
-int
-mp_Afs_init(void)
-{
-    extern int Afs_xsetgroups(), afs_xioctl(), afs3_syscall();
-
-    AFS_GLOCK();
-    ((struct sysent *)(&sysent[AFS_SYSCALL]))->sy_call = afs3_syscall;
-#ifdef SY_NARG
-    ((struct sysent *)(&sysent[AFS_SYSCALL]))->sy_info = 6;
-#else
-    ((struct sysent *)(&sysent[AFS_SYSCALL]))->sy_parallel = 0;
-    ((struct sysent *)(&sysent[AFS_SYSCALL]))->sy_narg = 6;
-#endif
-
-    ((struct sysent *)(&sysent[SYS_setgroups]))->sy_call = Afs_xsetgroups;
-    afs_xioctl_func = afsxioctl;
-    afs_xsetgroups_func = afsxsetgroups;
-    afs_syscall_func = afssyscall;
-    AFS_GUNLOCK();
-
-    return 0;
-}
diff --git a/src/afs/DUX/osi_vm.c b/src/afs/DUX/osi_vm.c
deleted file mode 100644 (file)
index 853d5e6..0000000
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-#include <afsconfig.h>
-#include "afs/param.h"
-
-RCSID
-    ("$Header$");
-
-#include "afs/sysincludes.h"   /* Standard vendor system headers */
-#include "afsincludes.h"       /* Afs-based standard headers */
-#include "afs/afs_stats.h"     /* statistics */
-#include <vm/vm_ubc.h>
-#include <values.h>
-
-/* Try to discard pages, in order to recycle a vcache entry.
- *
- * We also make some sanity checks:  ref count, open count, held locks.
- *
- * We also do some non-VM-related chores, such as releasing the cred pointer
- * (for AIX and Solaris) and releasing the gnode (for AIX).
- *
- * Locking:  afs_xvcache lock is held.  If it is dropped and re-acquired,
- *   *slept should be set to warn the caller.
- *
- * Formerly, afs_xvcache was dropped and re-acquired for Solaris, but now it
- * is not dropped and re-acquired for any platform.  It may be that *slept is
- * therefore obsolescent.
- *
- * OSF/1 Locking:  VN_LOCK has been called.
- */
-int
-osi_VM_FlushVCache(struct vcache *avc, int *slept)
-{
-    if (avc->vrefCount > 1)
-       return EBUSY;
-
-    if (avc->opens)
-       return EBUSY;
-
-    /* if a lock is held, give up */
-    if (CheckLock(&avc->lock) || afs_CheckBozonLock(&avc->pvnLock))
-       return EBUSY;
-
-    AFS_GUNLOCK();
-    ubc_invalidate(AFSTOV(avc)->v_object, 0, 0, B_INVAL);
-    AFS_GLOCK();
-
-    return 0;
-}
-
-/*
- * osi_ubc_flush_dirty_and_wait -- ensure all dirty pages cleaned
- *
- * Alpha OSF/1 doesn't make it easy to wait for all dirty pages to be cleaned.
- * NFS tries to do this by calling waitforio(), which waits for v_numoutput
- * to go to zero.  But that isn't good enough, because afs_putpage() doesn't
- * increment v_numoutput until it has obtained the vcache entry lock.  Suppose
- * that Process A, trying to flush a page, is waiting for that lock, and
- * Process B tries to close the file.  Process B calls waitforio() which thinks
- * that everything is cool because v_numoutput is still zero.  Process B then
- * proceeds to call afs_StoreAllSegments().  Finally when B is finished, A gets
- * to proceed and flush its page.  But then it's too late because the file is
- * already closed.
- *
- * (I suspect that waitforio() is not adequate for NFS, just as it isn't
- * adequate for us.  But that's not my problem.)
- *
- * The only way we can be sure that there are no more dirty pages is if there
- * are no more pages with pg_busy set.  We look for them on the cleanpl.
- *
- * For some reason, ubc_flush_dirty() only looks at the dirtypl, not the
- * dirtywpl.  I don't know why this is good enough, but I assume it is.  By
- * the same token, I only look for busy pages on the cleanpl, not the cleanwpl.
- *
- * Called with the global lock NOT held.
- */
-static void
-osi_ubc_flush_dirty_and_wait(struct vnode *vp, int flags)
-{
-    int retry;
-    vm_page_t pp;
-    int first;
-
-    do {
-       struct vm_ubc_object *vop;
-       vop = (struct vm_ubc_object *)(vp->v_object);
-       ubc_flush_dirty(vop, flags);
-
-       vm_object_lock(vop);
-       if (vop->vu_dirtypl)
-           /* shouldn't happen, but who knows */
-           retry = 1;
-       else {
-           retry = 0;
-           if (vop->vu_cleanpl) {
-               for (first = 1, pp = vop->vu_cleanpl;
-                    first || pp != vop->vu_cleanpl;
-                    first = 0, pp = pp->pg_onext) {
-                   if (pp->pg_busy) {
-                       retry = 1;
-                       pp->pg_wait = 1;
-                       assert_wait_mesg((vm_offset_t) pp, FALSE, "pg_wait");
-                       vm_object_unlock(vop);
-                       thread_block();
-                       break;
-                   }
-               }
-           }
-           if (retry)
-               continue;
-       }
-       vm_object_unlock(vop);
-    } while (retry);
-}
-
-/* Try to store pages to cache, in order to store a file back to the server.
- *
- * Locking:  the vcache entry's lock is held.  It will usually be dropped and
- * re-obtained.
- */
-void
-osi_VM_StoreAllSegments(struct vcache *avc)
-{
-    ReleaseWriteLock(&avc->lock);
-    AFS_GUNLOCK();
-    osi_ubc_flush_dirty_and_wait(AFSTOV(avc), 0);
-    AFS_GLOCK();
-    ObtainWriteLock(&avc->lock, 94);
-}
-
-/* Try to invalidate pages, for "fs flush" or "fs flushv"; or
- * try to free pages, when deleting a file.
- *
- * Locking:  the vcache entry's lock is held.  It may be dropped and 
- * re-obtained.
- *
- * Since we drop and re-obtain the lock, we can't guarantee that there won't
- * be some pages around when we return, newly created by concurrent activity.
- */
-void
-osi_VM_TryToSmush(struct vcache *avc, struct AFS_UCRED *acred, int sync)
-{
-    ReleaseWriteLock(&avc->lock);
-    AFS_GUNLOCK();
-    osi_ubc_flush_dirty_and_wait(AFSTOV(avc), 0);
-    ubc_invalidate(AFSTOV(avc)->v_object, 0, 0, B_INVAL);
-    AFS_GLOCK();
-    ObtainWriteLock(&avc->lock, 59);
-}
-
-/* Purge VM for a file when its callback is revoked.
- *
- * Locking:  No lock is held, not even the global lock.
- */
-void
-osi_VM_FlushPages(struct vcache *avc, struct AFS_UCRED *credp)
-{
-    ubc_flush_dirty(AFSTOV(avc)->v_object, 0);
-    ubc_invalidate(AFSTOV(avc)->v_object, 0, 0, B_INVAL);
-}
-
-/* Purge pages beyond end-of-file, when truncating a file.
- *
- * Locking:  no lock is held, not even the global lock.
- * activeV is raised.  This is supposed to block pageins, but at present
- * it only works on Solaris.
- */
-void
-osi_VM_Truncate(struct vcache *avc, int alen, struct AFS_UCRED *acred)
-{
-    ubc_invalidate(AFSTOV(avc)->v_object, alen, MAXINT - alen, B_INVAL);
-}
diff --git a/src/afs/DUX/osi_vnodeops.c b/src/afs/DUX/osi_vnodeops.c
deleted file mode 100644 (file)
index 988c23f..0000000
+++ /dev/null
@@ -1,1202 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * vnodeops structure and Digital Unix specific ops and support routines.
- */
-
-#include <afsconfig.h>
-#include "afs/param.h"
-
-RCSID
-    ("$Header$");
-
-
-#include "afs/sysincludes.h"   /* Standard vendor system headers */
-#include "afsincludes.h"       /* Afs-based standard headers */
-#include "afs/afs_stats.h"     /* statistics */
-#include <vm/vm_mmap.h>
-#include <vm/vm_ubc.h>
-#include "afs/afs_cbqueue.h"
-#include "afs/nfsclient.h"
-#include "afs/afs_osidnlc.h"
-
-
-extern int afs_lookup(), afs_create(), afs_noop(), afs_open(), afs_close();
-extern int afs_access(), afs_getattr(), afs_setattr(), afs_badop();
-extern int afs_fsync(), afs_seek(), afs_remove(), afs_link(), afs_rename();
-extern int afs_mkdir(), afs_rmdir(), afs_symlink(), afs_readdir();
-extern int afs_readlink(), afs_lockctl();
-extern int vn_pathconf_default(), seltrue();
-
-int mp_afs_lookup(), mp_afs_create(), mp_afs_open();
-int mp_afs_access(), mp_afs_getattr(), mp_afs_setattr(), mp_afs_ubcrdwr();
-int mp_afs_ubcrdwr(), mp_afs_mmap();
-int mp_afs_fsync(), mp_afs_seek(), mp_afs_remove(), mp_afs_link();
-int mp_afs_rename(), mp_afs_mkdir(), mp_afs_rmdir(), mp_afs_symlink();
-int mp_afs_readdir(), mp_afs_readlink(), mp_afs_abortop(), mp_afs_inactive();
-int mp_afs_reclaim(), mp_afs_bmap(), mp_afs_strategy(), mp_afs_print();
-int mp_afs_page_read(), mp_afs_page_write(), mp_afs_swap(), mp_afs_bread();
-int mp_afs_brelse(), mp_afs_lockctl(), mp_afs_syncdata(), mp_afs_close();
-int mp_afs_closex();
-int mp_afs_ioctl();
-
-/* AFS vnodeops */
-struct vnodeops Afs_vnodeops = {
-    mp_afs_lookup,
-    mp_afs_create,
-    afs_noop,                  /* vn_mknod */
-    mp_afs_open,
-    mp_afs_close,
-    mp_afs_access,
-    mp_afs_getattr,
-    mp_afs_setattr,
-    mp_afs_ubcrdwr,
-    mp_afs_ubcrdwr,
-    mp_afs_ioctl,              /* vn_ioctl */
-    seltrue,                   /* vn_select */
-    mp_afs_mmap,
-    mp_afs_fsync,
-    mp_afs_seek,
-    mp_afs_remove,
-    mp_afs_link,
-    mp_afs_rename,
-    mp_afs_mkdir,
-    mp_afs_rmdir,
-    mp_afs_symlink,
-    mp_afs_readdir,
-    mp_afs_readlink,
-    mp_afs_abortop,
-    mp_afs_inactive,
-    mp_afs_reclaim,
-    mp_afs_bmap,
-    mp_afs_strategy,
-    mp_afs_print,
-    mp_afs_page_read,
-    mp_afs_page_write,
-    mp_afs_swap,
-    mp_afs_bread,
-    mp_afs_brelse,
-    mp_afs_lockctl,
-    mp_afs_syncdata,
-    afs_noop,                  /* Lock */
-    afs_noop,                  /* unLock */
-    afs_noop,                  /* get ext attrs */
-    afs_noop,                  /* set ext attrs */
-    afs_noop,                  /* del ext attrs */
-    vn_pathconf_default,
-};
-struct vnodeops *afs_ops = &Afs_vnodeops;
-
-/* vnode file operations, and our own */
-extern int vn_read();
-extern int vn_write();
-extern int vn_ioctl();
-extern int vn_select();
-extern int afs_closex();
-
-struct fileops afs_fileops = {
-    vn_read,
-    vn_write,
-    vn_ioctl,
-    vn_select,
-    mp_afs_closex,
-};
-
-mp_afs_lookup(adp, ndp)
-     struct vcache *adp;
-     struct nameidata *ndp;
-{
-    int code;
-    char aname[MAXNAMLEN + 1];  /* XXX */
-    struct vcache **avcp = (struct vcache **)&(ndp->ni_vp);
-    struct ucred *acred = ndp->ni_cred;
-    int wantparent = ndp->ni_nameiop & WANTPARENT;
-    int opflag = ndp->ni_nameiop & OPFLAG;
-    AFS_GLOCK();
-    memcpy(aname, ndp->ni_ptr, ndp->ni_namelen);
-    aname[ndp->ni_namelen] = '\0';
-    code = afs_lookup(adp, aname, avcp, acred, opflag, wantparent);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_create(ndp, attrs)
-     struct nameidata *ndp;
-     struct vattr *attrs;
-{
-    int code;
-    register struct vcache *adp = VTOAFS(ndp->ni_dvp);
-    char *aname = ndp->ni_dent.d_name;
-    enum vcexcl aexcl = NONEXCL;        /* XXX - create called properly */
-    int amode = 0;              /* XXX - checked in higher level */
-    struct vcache **avcp = (struct vcache **)&(ndp->ni_vp);
-    struct ucred *acred = ndp->ni_cred;
-    AFS_GLOCK();
-    code = afs_create(adp, aname, attrs, aexcl, 
-                     amode, avcp, acred);
-
-    AFS_GUNLOCK();
-    afs_PutVCache(adp);
-    return code;
-}
-
-mp_afs_open(avcp, aflags, acred)
-     struct vcache **avcp;
-     afs_int32 aflags;
-     struct AFS_UCRED *acred;
-{
-    int code;
-    AFS_GLOCK();
-    code = afs_open(avcp, aflags, acred);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_access(avc, amode, acred)
-     struct vcache *avc;
-     afs_int32 amode;
-     struct AFS_UCRED *acred;
-{
-    int code;
-    AFS_GLOCK();
-    code = afs_access(avc, amode, acred);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_close(avc, flags, cred)
-     struct vnode *avc;
-     int flags;
-     struct ucred *cred;
-{
-    int code;
-    AFS_GLOCK();
-    code = afs_close(avc, flags, cred);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_getattr(avc, attrs, acred)
-     struct vcache *avc;
-     struct vattr *attrs;
-     struct AFS_UCRED *acred;
-{
-    int code;
-    AFS_GLOCK();
-    code = afs_getattr(avc, attrs, acred);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_setattr(avc, attrs, acred)
-     struct vcache *avc;
-     struct vattr *attrs;
-     struct AFS_UCRED *acred;
-{
-    int code;
-    AFS_GLOCK();
-    code = afs_setattr(avc, attrs, acred);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_fsync(avc, fflags, acred, waitfor)
-     struct vcache *avc;
-     int fflags;
-     struct AFS_UCRED *acred;
-     int waitfor;
-{
-    int code;
-    AFS_GLOCK();
-    code = afs_fsync(avc, fflags, acred, waitfor);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_remove(ndp)
-     struct nameidata *ndp;
-{
-    int code;
-    register struct vcache *adp = VTOAFS(ndp->ni_dvp);
-    char *aname = ndp->ni_dent.d_name;
-    struct ucred *acred = ndp->ni_cred;
-    AFS_GLOCK();
-    code = afs_remove(adp, aname, acred);
-    afs_PutVCache(adp);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_link(avc, ndp)
-     struct vcache *avc;
-     struct nameidata *ndp;
-{
-    int code;
-    struct vcache *adp = VTOAFS(ndp->ni_dvp);
-    char *aname = ndp->ni_dent.d_name;
-    struct ucred *acred = ndp->ni_cred;
-    AFS_GLOCK();
-    code = afs_link(avc, adp, aname, acred);
-    AFS_GUNLOCK();
-    afs_PutVCache(adp);
-    return code;
-}
-
-mp_afs_rename(fndp, tndp)
-     struct nameidata *fndp, *tndp;
-{
-    int code;
-    struct vcache *aodp = VTOAFS(fndp->ni_dvp);
-    char *aname1 = fndp->ni_dent.d_name;
-    struct vcache *andp = VTOAFS(tndp->ni_dvp);
-    char *aname2 = tndp->ni_dent.d_name;
-    struct ucred *acred = tndp->ni_cred;
-    AFS_GLOCK();
-    code = afs_rename(aodp, aname1, andp, aname2, acred);
-    AFS_RELE(tndp->ni_dvp);
-    if (tndp->ni_vp != NULL) {
-        AFS_RELE(tndp->ni_vp);
-    }
-    AFS_RELE(fndp->ni_dvp);
-    AFS_RELE(fndp->ni_vp);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_mkdir(ndp, attrs)
-     struct nameidata *ndp;
-     struct vattr *attrs;
-{
-    int code;
-    register struct vcache *adp = VTOAFS(ndp->ni_dvp);
-    char *aname = ndp->ni_dent.d_name;
-    register struct vcache **avcp = (struct vcache **)&(ndp->ni_vp);
-    struct ucred *acred = ndp->ni_cred;
-    AFS_GLOCK();
-    code = afs_mkdir(adp, aname, attrs, avcp, acred);
-    AFS_RELE(adp);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_rmdir(ndp)
-     struct nameidata *ndp;
-{
-    int code;
-    register struct vcache *adp = VTOAFS(ndp->ni_dvp);
-    char *aname = ndp->ni_dent.d_name;
-    struct ucred *acred = ndp->ni_cred;
-    AFS_GLOCK();
-    code = afs_rmdir(adp, aname, acred);
-    afs_PutVCache(adp);
-    afs_PutVCache(ndp->ni_vp);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_symlink(ndp, attrs, atargetName)
-     struct nameidata *ndp;
-     struct vattr *attrs;
-     register char *atargetName;
-{
-    int code;
-    register struct vcache *adp = VTOAFS(ndp->ni_dvp);
-    char *aname = ndp->ni_dent.d_name;
-    struct ucred *acred = ndp->ni_cred;
-    AFS_GLOCK();
-    code = afs_symlink(adp, aname, attrs, atargetName, acred);
-    AFS_RELE(ndp->ni_dvp);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_readdir(avc, auio, acred, eofp)
-     struct vcache *avc;
-     struct uio *auio;
-     struct AFS_UCRED *acred;
-     int *eofp;
-{
-    int code;
-    AFS_GLOCK();
-    code = afs_readdir(avc, auio, acred, eofp);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_readlink(avc, auio, acred)
-     struct vcache *avc;
-     struct uio *auio;
-     struct AFS_UCRED *acred;
-{
-    int code;
-    AFS_GLOCK();
-    code = afs_readlink(avc, auio, acred);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_lockctl(avc, af, flag, acred, clid, offset)
-     struct vcache *avc;
-     struct eflock *af;
-     struct AFS_UCRED *acred;
-     int flag;
-     pid_t clid;
-     off_t offset;
-{
-    int code;
-    AFS_GLOCK();
-    code = afs_lockctl(avc, af, flag, acred, clid, offset);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_closex(afd)
-     struct file *afd;
-{
-    int code;
-    AFS_GLOCK();
-    code = afs_closex(afd);
-    AFS_GUNLOCK();
-    return code;
-}
-
-mp_afs_seek(avc, oldoff, newoff, cred)
-     struct vcache *avc;
-     off_t oldoff, newoff;
-     struct ucred *cred;
-{
-    if ((int)newoff < 0)
-       return (EINVAL);
-    else
-       return (0);
-}
-
-mp_afs_abortop(ndp)
-     struct nameidata *ndp;
-{
-    return (0);
-}
-
-mp_afs_inactive(avc, acred)
-     register struct vcache *avc;
-     struct AFS_UCRED *acred;
-{
-    AFS_GLOCK();
-    afs_InactiveVCache(avc, acred);
-    AFS_GUNLOCK();
-}
-
-
-mp_afs_reclaim(avc)
-     struct vcache *avc;
-{
-    return (0);
-}
-
-mp_afs_print(avc)
-     struct vcache *avc;
-{
-    return (0);
-}
-
-mp_afs_page_read(avc, uio, acred)
-     struct vcache *avc;
-     struct uio *uio;
-     struct ucred *acred;
-{
-    int error;
-    struct vrequest treq;
-
-    AFS_GLOCK();
-    error = afs_rdwr(avc, uio, UIO_READ, 0, acred);
-    afs_Trace3(afs_iclSetp, CM_TRACE_PAGE_READ, ICL_TYPE_POINTER, avc,
-              ICL_TYPE_INT32, error, ICL_TYPE_INT32, avc->states);
-    if (error) {
-       error = EIO;
-    } else if ((avc->states & CWired) == 0) {
-       afs_InitReq(&treq, acred);
-       ObtainWriteLock(&avc->lock, 161);
-       afs_Wire(avc, &treq);
-       ReleaseWriteLock(&avc->lock);
-    }
-    AFS_GUNLOCK();
-    return (error);
-}
-
-
-mp_afs_page_write(avc, uio, acred, pager, offset)
-     struct vcache *avc;
-     struct uio *uio;
-     struct ucred *acred;
-     memory_object_t pager;
-     vm_offset_t offset;
-{
-    int error;
-
-    AFS_GLOCK();
-    error = afs_rdwr(avc, uio, UIO_WRITE, 0, acred);
-    afs_Trace3(afs_iclSetp, CM_TRACE_PAGE_WRITE, ICL_TYPE_POINTER, avc,
-              ICL_TYPE_INT32, error, ICL_TYPE_INT32, avc->states);
-    if (error) {
-       error = EIO;
-    }
-    AFS_GUNLOCK();
-    return (error);
-}
-
-
-int DO_FLUSH = 1;
-mp_afs_ubcrdwr(avc, uio, ioflag, cred)
-     struct vcache *avc;
-     struct uio *uio;
-     int ioflag;
-     struct ucred *cred;
-{
-    register afs_int32 code;
-    register char *data;
-    afs_int32 fileBase, size, cnt = 0;
-    afs_int32 pageBase;
-    register afs_int32 tsize;
-    register afs_int32 pageOffset;
-    int eof;
-    struct vrequest treq;
-    int rw = uio->uio_rw;
-    int rv, flags;
-    int newpage = 0;
-    vm_page_t page;
-    afs_int32 save_resid;
-    struct dcache *tdc;
-    int didFakeOpen = 0;
-    int counter = 0;
-
-    AFS_GLOCK();
-    afs_InitReq(&treq, cred);
-    if (AFS_NFSXLATORREQ(cred) && rw == UIO_READ) {
-       if (!afs_AccessOK
-           (avc, PRSFS_READ, &treq,
-            CHECK_MODE_BITS | CMB_ALLOW_EXEC_AS_READ)) {
-           AFS_GUNLOCK();
-           return EACCES;
-       }
-    }
-    afs_Trace4(afs_iclSetp, CM_TRACE_VMRW, ICL_TYPE_POINTER, avc,
-              ICL_TYPE_INT32, (rw == UIO_WRITE ? 1 : 0), ICL_TYPE_LONG,
-              uio->uio_offset, ICL_TYPE_LONG, uio->uio_resid);
-    code = afs_VerifyVCache(avc, &treq);
-    if (code) {
-       code = afs_CheckCode(code, &treq, 35);
-       AFS_GUNLOCK();
-       return code;
-    }
-    if (vType(avc) != VREG) {
-       AFS_GUNLOCK();
-       return EISDIR;          /* can't read or write other things */
-    }
-    afs_BozonLock(&avc->pvnLock, avc);
-    osi_FlushPages(avc, cred); /* hold bozon lock, but not basic vnode lock */
-    ObtainWriteLock(&avc->lock, 162);
-    /* adjust parameters when appending files */
-    if ((ioflag & IO_APPEND) && uio->uio_rw == UIO_WRITE)
-       uio->uio_offset = avc->m.Length;        /* write at EOF position */
-    if (uio->uio_rw == UIO_WRITE) {
-       avc->states |= CDirty;
-       afs_FakeOpen(avc);
-       didFakeOpen = 1;
-       /*
-        * before starting any I/O, we must ensure that the file is big enough
-        * to hold the results (since afs_putpage will be called to force
-        * the I/O.
-        */
-       size = uio->afsio_resid + uio->afsio_offset;    /* new file size */
-       if (size > avc->m.Length)
-           avc->m.Length = size;       /* file grew */
-       avc->m.Date = osi_Time();       /* Set file date (for ranlib) */
-       if (uio->afsio_resid > PAGE_SIZE)
-           cnt = uio->afsio_resid / PAGE_SIZE;
-       save_resid = uio->afsio_resid;
-    }
-
-    while (1) {
-       /*
-        * compute the amount of data to move into this block,
-        * based on uio->afsio_resid.
-        */
-       size = uio->afsio_resid;        /* transfer size */
-       fileBase = uio->afsio_offset;   /* start file position */
-       pageBase = fileBase & ~(PAGE_SIZE - 1); /* file position of the page */
-       pageOffset = fileBase & (PAGE_SIZE - 1);        /* start offset within page */
-       tsize = PAGE_SIZE - pageOffset; /* amount left in this page */
-       /*
-        * we'll read tsize bytes,
-        * but first must make sure tsize isn't too big
-        */
-       if (tsize > size)
-           tsize = size;       /* don't read past end of request */
-       eof = 0;                /* flag telling us if we hit the EOF on the read */
-       if (uio->uio_rw == UIO_READ) {  /* we're doing a read operation */
-           /* don't read past EOF */
-           if (tsize + fileBase > avc->m.Length) {
-               tsize = avc->m.Length - fileBase;
-               eof = 1;        /* we did hit the EOF */
-               if (tsize < 0)
-                   tsize = 0;  /* better safe than sorry */
-           }
-       }
-       if (tsize <= 0)
-           break;              /* nothing to transfer, we're done */
-
-       /* Purge dirty chunks of file if there are too many dirty chunks.
-        * Inside the write loop, we only do this at a chunk boundary.
-        * Clean up partial chunk if necessary at end of loop.
-        */
-       if (uio->uio_rw == UIO_WRITE && counter > 0
-           && AFS_CHUNKOFFSET(fileBase) == 0) {
-           code = afs_DoPartialWrite(avc, &treq);
-           avc->states |= CDirty;
-       }
-
-       if (code) {
-           break;
-       }
-
-       flags = 0;
-       ReleaseWriteLock(&avc->lock);
-       AFS_GUNLOCK();
-#ifdef AFS_DUX50_ENV
-       code =
-           ubc_lookup(AFSTOV(avc)->v_object, pageBase, PAGE_SIZE, PAGE_SIZE,
-                      &page, &flags, NULL);
-#else
-       code =
-           ubc_lookup(AFSTOV(avc)->v_object, pageBase, PAGE_SIZE, PAGE_SIZE,
-                      &page, &flags);
-#endif
-       AFS_GLOCK();
-       ObtainWriteLock(&avc->lock, 163);
-
-       if (code) {
-           break;
-       }
-       if (flags & B_NOCACHE) {
-           /*
-            * No page found. We should not read the page in if
-            * 1. the write starts on a page edge (ie, pageoffset == 0)
-            * and either
-            * 1. we will fill the page  (ie, size == PAGESIZE), or
-            * 2. we are writing past eof
-            */
-           if ((uio->uio_rw == UIO_WRITE)
-               &&
-               ((pageOffset == 0
-                 && (size == PAGE_SIZE || fileBase >= avc->m.Length)))) {
-               struct vnode *vp = AFSTOV(avc);
-               /* we're doing a write operation past eof; no need to read it */
-               newpage = 1;
-               AFS_GUNLOCK();
-               ubc_page_zero(page, 0, PAGE_SIZE);
-               ubc_page_release(page, B_DONE);
-               AFS_GLOCK();
-           } else {
-               /* page wasn't cached, read it in. */
-               struct buf *bp;
-
-               AFS_GUNLOCK();
-               bp = ubc_bufalloc(page, 1, PAGE_SIZE, 1, B_READ);
-               AFS_GLOCK();
-               bp->b_dev = 0;
-               bp->b_vp = AFSTOV(avc);
-               bp->b_blkno = btodb(pageBase);
-               ReleaseWriteLock(&avc->lock);
-               code = afs_ustrategy(bp, cred); /* do the I/O */
-               ObtainWriteLock(&avc->lock, 164);
-               AFS_GUNLOCK();
-               ubc_sync_iodone(bp);
-               AFS_GLOCK();
-               if (code) {
-                   AFS_GUNLOCK();
-                   ubc_page_release(page, 0);
-                   AFS_GLOCK();
-                   break;
-               }
-           }
-       }
-       AFS_GUNLOCK();
-       ubc_page_wait(page);
-       data = ubc_load(page, pageOffset, page_size);
-       AFS_GLOCK();
-       ReleaseWriteLock(&avc->lock);   /* uiomove may page fault */
-       AFS_GUNLOCK();
-       code = uiomove(data + pageOffset, tsize, uio);
-       ubc_unload(page, pageOffset, page_size);
-       if (uio->uio_rw == UIO_WRITE) {
-           vm_offset_t toffset;
-
-           /* Mark the page dirty and release it to avoid a deadlock
-            * in ubc_dirty_kluster when more than one process writes
-            * this page at the same time. */
-           toffset = page->pg_offset;
-           flags |= B_DIRTY;
-           ubc_page_release(page, flags);
-
-           if (cnt > 10) {
-               vm_page_t pl;
-               int kpcnt;
-               struct buf *bp;
-
-               /* We released the page, so we can get a null page
-                * list if another thread calls the strategy routine.
-                */
-               pl = ubc_dirty_kluster(AFSTOV(avc)->v_object, NULL, toffset,
-                                      0, B_WANTED, FALSE, &kpcnt);
-               if (pl) {
-                   bp = ubc_bufalloc(pl, 1, PAGE_SIZE, 1, B_WRITE);
-                   bp->b_dev = 0;
-                   bp->b_vp = AFSTOV(avc);
-                   bp->b_blkno = btodb(pageBase);
-                   AFS_GLOCK();
-                   code = afs_ustrategy(bp, cred);     /* do the I/O */
-                   AFS_GUNLOCK();
-                   ubc_sync_iodone(bp);
-                   if (code) {
-                       AFS_GLOCK();
-                       ObtainWriteLock(&avc->lock, 415);
-                       break;
-                   }
-               }
-           }
-       } else {
-           ubc_page_release(page, flags);
-       }
-       AFS_GLOCK();
-       ObtainWriteLock(&avc->lock, 165);
-       /*
-        * If reading at a chunk boundary, start prefetch of next chunk.
-        */
-       if (uio->uio_rw == UIO_READ
-           && (counter == 0 || AFS_CHUNKOFFSET(fileBase) == 0)) {
-           tdc = afs_FindDCache(avc, fileBase);
-           if (tdc) {
-               if (!(tdc->mflags & DFNextStarted))
-                   afs_PrefetchChunk(avc, tdc, cred, &treq);
-               afs_PutDCache(tdc);
-           }
-       }
-       counter++;
-       if (code)
-           break;
-    }
-    if (didFakeOpen)
-       afs_FakeClose(avc, cred);
-    if (uio->uio_rw == UIO_WRITE && code == 0 && (avc->states & CDirty)) {
-       code = afs_DoPartialWrite(avc, &treq);
-    }
-    ReleaseWriteLock(&avc->lock);
-    afs_BozonUnlock(&avc->pvnLock, avc);
-    if (DO_FLUSH || (!newpage && (cnt < 10))) {
-       AFS_GUNLOCK();
-       ubc_flush_dirty(AFSTOV(avc)->v_object, flags);
-       AFS_GLOCK();
-    }
-
-    ObtainSharedLock(&avc->lock, 409);
-    if (!code) {
-       if (avc->vc_error) {
-           code = avc->vc_error;
-       }
-    }
-    /* This is required since we may still have dirty pages after the write.
-     * I could just let close do the right thing, but stat's before the close
-     * return the wrong length.
-     */
-    if (code == EDQUOT || code == ENOSPC) {
-       uio->uio_resid = save_resid;
-       UpgradeSToWLock(&avc->lock, 410);
-       osi_ReleaseVM(avc, cred);
-       ConvertWToSLock(&avc->lock);
-    }
-    ReleaseSharedLock(&avc->lock);
-
-    if (!code && (ioflag & IO_SYNC) && (uio->uio_rw == UIO_WRITE)
-       && !AFS_NFSXLATORREQ(cred)) {
-       code = afs_fsync(avc, 0, cred, 0);
-    }
-  out:
-    code = afs_CheckCode(code, &treq, 36);
-    AFS_GUNLOCK();
-    return code;
-}
-
-int
-mp_afs_ioctl(struct vnode *vp, int com, caddr_t data, int fflag,
-            struct ucred *cred, int *retval)
-{
-    return ENOSYS;
-}
-
-/*
- * Now for some bad news.  Since we artificially hold on to vnodes by doing
- * and extra VNHOLD in afs_NewVCache(), there is no way for us to know
- * when we need to flush the pages when a program exits.  Particularly
- * if it closes the file after mapping it R/W.
- *
- */
-
-mp_afs_mmap(avc, offset, map, addrp, len, prot, maxprot, flags, cred)
-     register struct vcache *avc;
-     vm_offset_t offset;
-     vm_map_t map;
-     vm_offset_t *addrp;
-     vm_size_t len;
-     vm_prot_t prot;
-     vm_prot_t maxprot;
-     int flags;
-     struct ucred *cred;
-{
-    struct vp_mmap_args args;
-    register struct vp_mmap_args *ap = &args;
-    struct vnode *vp = AFSTOV(avc);
-    int code;
-    struct vrequest treq;
-#if    !defined(DYNEL)
-    extern kern_return_t u_vp_create();
-#endif
-
-    AFS_GLOCK();
-    afs_InitReq(&treq, cred);
-    code = afs_VerifyVCache(avc, &treq);
-    if (code) {
-       code = afs_CheckCode(code, &treq, 37);
-       AFS_GUNLOCK();
-       return code;
-    }
-    afs_BozonLock(&avc->pvnLock, avc);
-    osi_FlushPages(avc, cred); /* ensure old pages are gone */
-    afs_BozonUnlock(&avc->pvnLock, avc);
-    ObtainWriteLock(&avc->lock, 166);
-    avc->states |= CMAPPED;
-    ReleaseWriteLock(&avc->lock);
-    ap->a_offset = offset;
-    ap->a_vaddr = addrp;
-    ap->a_size = len;
-    ap->a_prot = prot, ap->a_maxprot = maxprot;
-    ap->a_flags = flags;
-    AFS_GUNLOCK();
-    code = u_vp_create(map, vp->v_object, (vm_offset_t) ap);
-    AFS_GLOCK();
-    code = afs_CheckCode(code, &treq, 38);
-    AFS_GUNLOCK();
-    return code;
-}
-
-
-int
-mp_afs_getpage(vop, offset, len, protp, pl, plsz,
-#ifdef AFS_DUX50_ENV
-              policy,
-#else
-              mape, addr,
-#endif
-              rw, cred)
-     vm_ubc_object_t vop;
-     vm_offset_t offset;
-     vm_size_t len;
-     vm_prot_t *protp;
-     vm_page_t *pl;
-     int plsz;
-#ifdef AFS_DUX50_ENV
-     struct vm_policy *policy;
-#else
-     vm_map_entry_t mape;
-     vm_offset_t addr;
-#endif
-     int rw;
-     struct ucred *cred;
-{
-    register afs_int32 code;
-    struct vrequest treq;
-    int flags = 0;
-    int i, pages = (len + PAGE_SIZE - 1) >> page_shift;
-    vm_page_t *pagep;
-    vm_offset_t off;
-
-    struct vcache *avc = VTOAFS(vop->vu_vp);
-
-    /* first, obtain the proper lock for the VM system */
-
-    AFS_GLOCK();
-    afs_InitReq(&treq, cred);
-    code = afs_VerifyVCache(avc, &treq);
-    if (code) {
-       *pl = VM_PAGE_NULL;
-       code = afs_CheckCode(code, &treq, 39);  /* failed to get it */
-       AFS_GUNLOCK();
-       return code;
-    }
-
-    /* clean all dirty pages for this vnode */
-    AFS_GUNLOCK();
-    ubc_flush_dirty(vop, 0);
-    AFS_GLOCK();
-
-    afs_BozonLock(&avc->pvnLock, avc);
-    ObtainWriteLock(&avc->lock, 167);
-    afs_Trace4(afs_iclSetp, CM_TRACE_PAGEIN, ICL_TYPE_POINTER, avc,
-              ICL_TYPE_LONG, offset, ICL_TYPE_LONG, len, ICL_TYPE_INT32,
-              (int)rw);
-    for (i = 0; i < pages; i++) {
-       pagep = &pl[i];
-       off = offset + PAGE_SIZE * i;
-       if (protp)
-           protp[i] = 0;
-       flags = 0;
-       ReleaseWriteLock(&avc->lock);
-       AFS_GUNLOCK();
-#ifdef AFS_DUX50_ENV
-       code =
-           ubc_lookup(AFSTOV(avc)->v_object, off, PAGE_SIZE, PAGE_SIZE,
-                      pagep, &flags, NULL);
-#else
-       code =
-           ubc_lookup(AFSTOV(avc)->v_object, off, PAGE_SIZE, PAGE_SIZE,
-                      pagep, &flags);
-#endif
-       AFS_GLOCK();
-       ObtainWriteLock(&avc->lock, 168);
-       if (code) {
-           goto out;
-       }
-       if (flags & B_NOCACHE) {        /* if (page) */
-           if ((rw & B_WRITE) && (offset + len >= avc->m.Length)) {
-               struct vnode *vp = AFSTOV(avc);
-               /* we're doing a write operation past eof; no need to read it */
-               AFS_GUNLOCK();
-               ubc_page_zero(*pagep, 0, PAGE_SIZE);
-               ubc_page_release(*pagep, B_DONE);
-               AFS_GLOCK();
-           } else {
-               /* page wasn't cached, read it in. */
-               struct buf *bp;
-
-               AFS_GUNLOCK();
-               bp = ubc_bufalloc(*pagep, 1, PAGE_SIZE, 1, B_READ);
-               AFS_GLOCK();
-               bp->b_dev = 0;
-               bp->b_vp = AFSTOV(avc);
-               bp->b_blkno = btodb(off);
-               ReleaseWriteLock(&avc->lock);
-               code = afs_ustrategy(bp, cred); /* do the I/O */
-               ObtainWriteLock(&avc->lock, 169);
-               AFS_GUNLOCK();
-               ubc_sync_iodone(bp);
-               AFS_GLOCK();
-               if (code) {
-                   AFS_GUNLOCK();
-                   ubc_page_release(pl[i], 0);
-                   AFS_GLOCK();
-                   goto out;
-               }
-           }
-       }
-       if ((rw & B_READ) == 0) {
-           AFS_GUNLOCK();
-#ifdef AFS_DUX50_ENV
-           ubc_page_dirty(pl[i], 0);
-#else
-           ubc_page_dirty(pl[i]);
-#endif
-           AFS_GLOCK();
-       } else {
-           if (protp && (flags & B_DIRTY) == 0) {
-               protp[i] = VM_PROT_WRITE;
-           }
-       }
-    }
-  out:
-    pl[i] = VM_PAGE_NULL;
-    ReleaseWriteLock(&avc->lock);
-    afs_BozonUnlock(&avc->pvnLock, avc);
-    afs_Trace3(afs_iclSetp, CM_TRACE_PAGEINDONE, ICL_TYPE_INT32, code,
-              ICL_TYPE_POINTER, *pagep, ICL_TYPE_INT32, flags);
-    code = afs_CheckCode(code, &treq, 40);
-    AFS_GUNLOCK();
-    return code;
-}
-
-
-int
-mp_afs_putpage(vop, pl, pcnt, flags, cred)
-     vm_ubc_object_t vop;
-     vm_page_t *pl;
-     int pcnt;
-     int flags;
-     struct ucred *cred;
-{
-    register afs_int32 code = 0;
-    struct vnode *vp = vop->vu_vp;
-    struct vcache *avc = VTOAFS(vp);
-    int i;
-
-    AFS_GLOCK();
-    afs_Trace4(afs_iclSetp, CM_TRACE_PAGEOUT, ICL_TYPE_POINTER, avc,
-              ICL_TYPE_INT32, pcnt, ICL_TYPE_INT32, vp->v_flag,
-              ICL_TYPE_INT32, flags);
-    if (flags & B_UBC) {
-       AFS_GUNLOCK();
-       VN_LOCK(vp);
-       if (vp->v_flag & VXLOCK) {
-           VN_UNLOCK(vp);
-           for (i = 0; i < pcnt; i++) {
-               ubc_page_release(pl[i], B_DONE | B_DIRTY);
-               pl[i] = VM_PAGE_NULL;
-           }
-           return (0);
-       } else {
-           VN_UNLOCK(vp);
-       }
-       AFS_GLOCK();
-    }
-
-    /* first, obtain the proper lock for the VM system */
-    afs_BozonLock(&avc->pvnLock, avc);
-    ObtainWriteLock(&avc->lock, 170);
-    for (i = 0; i < pcnt; i++) {
-       vm_page_t page = pl[i];
-       struct buf *bp;
-
-       /* write it out */
-       AFS_GUNLOCK();
-       bp = ubc_bufalloc(page, 1, PAGE_SIZE, 1, B_WRITE);
-       AFS_GLOCK();
-       bp->b_dev = 0;
-       bp->b_vp = AFSTOV(avc);
-       bp->b_blkno = btodb(page->pg_offset);
-       ReleaseWriteLock(&avc->lock);
-       code = afs_ustrategy(bp, cred); /* do the I/O */
-       ObtainWriteLock(&avc->lock, 171);
-       AFS_GUNLOCK();
-       ubc_sync_iodone(bp);
-       AFS_GLOCK();
-       if (code) {
-           goto done;
-       } else {
-           pl[i] = VM_PAGE_NULL;
-       }
-    }
-  done:
-    ReleaseWriteLock(&avc->lock);
-    afs_BozonUnlock(&avc->pvnLock, avc);
-    afs_Trace2(afs_iclSetp, CM_TRACE_PAGEOUTDONE, ICL_TYPE_INT32, code,
-              ICL_TYPE_INT32, avc->m.Length);
-    AFS_GUNLOCK();
-    return code;
-}
-
-
-int
-mp_afs_swap(avc, swapop, argp)
-     struct vcache *avc;
-     vp_swap_op_t swapop;
-     vm_offset_t argp;
-{
-    return EIO;
-}
-
-int
-mp_afs_syncdata(avc, flag, offset, length, cred)
-     struct vcache *avc;
-     int flag;
-     vm_offset_t offset;
-     vm_size_t length;
-     struct ucred *cred;
-{
-    /* NFS V3 makes this call, ignore it. We'll sync the data in afs_fsync. */
-    if (AFS_NFSXLATORREQ(cred))
-       return 0;
-    else
-       return EINVAL;
-}
-
-/* a freelist of one */
-struct buf *afs_bread_freebp = 0;
-
-/*
- *  Only rfs_read calls this, and it only looks at bp->b_un.b_addr.
- *  Thus we can use fake bufs (ie not from the real buffer pool).
- */
-mp_afs_bread(vp, lbn, bpp, cred)
-     struct ucred *cred;
-     struct vnode *vp;
-     daddr_t lbn;
-     struct buf **bpp;
-{
-    int offset, fsbsize, error;
-    struct buf *bp;
-    struct iovec iov;
-    struct uio uio;
-
-    AFS_GLOCK();
-    AFS_STATCNT(afs_bread);
-    fsbsize = vp->v_vfsp->vfs_bsize;
-    offset = lbn * fsbsize;
-    if (afs_bread_freebp) {
-       bp = afs_bread_freebp;
-       afs_bread_freebp = 0;
-    } else {
-       bp = (struct buf *)AFS_KALLOC(sizeof(*bp));
-       bp->b_un.b_addr = (caddr_t) AFS_KALLOC(fsbsize);
-    }
-
-    iov.iov_base = bp->b_un.b_addr;
-    iov.iov_len = fsbsize;
-    uio.afsio_iov = &iov;
-    uio.afsio_iovcnt = 1;
-    uio.afsio_seg = AFS_UIOSYS;
-    uio.afsio_offset = offset;
-    uio.afsio_resid = fsbsize;
-    *bpp = 0;
-    error = afs_read(VTOAFS(vp), &uio, cred, lbn, bpp, 0);
-    if (error) {
-       afs_bread_freebp = bp;
-       AFS_GUNLOCK();
-       return error;
-    }
-    if (*bpp) {
-       afs_bread_freebp = bp;
-    } else {
-       *(struct buf **)&bp->b_vp = bp; /* mark as fake */
-       *bpp = bp;
-    }
-    AFS_GUNLOCK();
-    return 0;
-}
-
-
-mp_afs_brelse(vp, bp)
-     struct vnode *vp;
-     struct buf *bp;
-{
-    AFS_GLOCK();
-    AFS_STATCNT(afs_brelse);
-    if ((struct buf *)bp->b_vp != bp) {        /* not fake */
-       brelse(bp);
-    } else if (afs_bread_freebp) {
-       AFS_KFREE(bp->b_un.b_addr, vp->v_vfsp->vfs_bsize);
-       AFS_KFREE(bp, sizeof(*bp));
-    } else {
-       afs_bread_freebp = bp;
-    }
-    AFS_GUNLOCK();
-}
-
-
-mp_afs_bmap(avc, abn, anvp, anbn)
-     register struct vcache *avc;
-     afs_int32 abn, *anbn;
-     struct vcache **anvp;
-{
-    AFS_GLOCK();
-    AFS_STATCNT(afs_bmap);
-    if (anvp)
-       *anvp = avc;
-    if (anbn)
-       *anbn = abn * (8192 / DEV_BSIZE);       /* in 512 byte units */
-    AFS_GUNLOCK();
-    return 0;
-}
-
-
-/* real strategy */
-mp_afs_strategy(abp)
-     register struct buf *abp;
-{
-    register afs_int32 code;
-
-    AFS_GLOCK();
-    AFS_STATCNT(afs_strategy);
-    code = afs_osi_MapStrategy(afs_ustrategy, abp);
-    AFS_GUNLOCK();
-    return code;
-}
-
-
-mp_afs_refer(vm_ubc_object_t vop)
-{
-    VREF(vop->vu_vp);
-}
-
-
-mp_afs_release(vm_ubc_object_t vop)
-{
-    vrele(vop->vu_vp);
-}
-
-
-mp_afs_write_check(vm_ubc_object_t vop, vm_page_t pp)
-{
-    return TRUE;
-}
-
-#ifdef AFS_DUX50_ENV
-int
-mp_afs_objtovp(vm_ubc_object_t vop, struct vnode **vp)
-{
-    *vp = vop->vu_vp;
-    return 0;
-}
-
-int
-mp_afs_setpgstamp(vm_page_t pp, unsigned int tick)
-{
-    pp->pg_stamp = tick;
-    return 0;
-}
-#endif
-
-
-struct vfs_ubcops afs_ubcops = {
-    mp_afs_refer,              /* refer vnode */
-    mp_afs_release,            /* release vnode */
-    mp_afs_getpage,            /* get page */
-    mp_afs_putpage,            /* put page */
-    mp_afs_write_check,                /* check writablity */
-#ifdef AFS_DUX50_ENV
-    mp_afs_objtovp,            /* get vnode pointer */
-    mp_afs_setpgstamp          /* set page stamp */
-#endif
-};
-
-
-/*
- * Cover function for lookup name using OSF equivalent, namei()
- *
- * Note, the result vnode (ni_vp) in the namei data structure is remains
- * locked after return.
- */
-lookupname(namep, seg, follow, dvpp, cvpp)
-     char *namep;              /* path name */
-     int seg;                  /* address space containing name */
-     int follow;               /* follow symbolic links */
-     struct vnode **dvpp;      /* result, containing parent vnode */
-     struct vnode **cvpp;      /* result, containing final component vnode */
-{
-    /* Should I use free-bee in u-area? */
-    struct nameidata *ndp = &u.u_nd;
-    int error;
-
-    ndp->ni_nameiop = ((follow) ? (LOOKUP | FOLLOW) : (LOOKUP));
-    ndp->ni_segflg = seg;
-    ndp->ni_dirp = namep;
-    error = namei(ndp);
-    if (dvpp != NULL)
-       *dvpp = ndp->ni_dvp;
-    if (cvpp != NULL)
-       *cvpp = ndp->ni_vp;
-    return (error);
-}
diff --git a/src/rx/DUX/rx_kmutex.c b/src/rx/DUX/rx_kmutex.c
deleted file mode 100644 (file)
index d82ea9c..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * rx_kmutex.c - mutex and condition variable macros for kernel environment.
- *
- * DUX implementation.
- */
-
-#include <afsconfig.h>
-#include "afs/param.h"
-
-RCSID
-    ("$Header$");
-
-/*
- * Currently everything is implemented in rx_kmutex.h
- */
diff --git a/src/rx/DUX/rx_kmutex.h b/src/rx/DUX/rx_kmutex.h
deleted file mode 100644 (file)
index 39a46e6..0000000
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * rx_kmutex.h - mutex and condition variable macros for kernel environment.
- *
- * DUX implementation.
- */
-
-#ifndef _RX_KMUTEX_H_
-#define _RX_KMUTEX_H_
-
-#ifdef AFS_DUX40_ENV
-
-#include <kern/lock.h>
-#include <kern/sched_prim.h>
-#include <sys/unix_defs.h>
-
-#define RX_ENABLE_LOCKS                1
-#define AFS_GLOBAL_RXLOCK_KERNEL
-
-/*
- * Condition variables
- *
- * In Digital Unix (OSF/1), we use something akin to the ancient sleep/wakeup
- * mechanism.  The condition variable itself plays no role; we just use its
- * address as a convenient unique number.
- */
-#define CV_INIT(cv,a,b,c)
-#define CV_DESTROY(cv)
-#define CV_WAIT(cv, lck)    { \
-                               int isGlockOwner = ISAFS_GLOCK(); \
-                               if (isGlockOwner) AFS_GUNLOCK();  \
-                               assert_wait((vm_offset_t)(cv), 0);      \
-                               MUTEX_EXIT(lck);        \
-                               thread_block();         \
-                               if (isGlockOwner) AFS_GLOCK();  \
-                               MUTEX_ENTER(lck); \
-                           }
-
-#define CV_TIMEDWAIT(cv,lck,t) { \
-                               int isGlockOwner = ISAFS_GLOCK(); \
-                               if (isGlockOwner) AFS_GUNLOCK();  \
-                               assert_wait((vm_offset_t)(cv), 0);      \
-                               thread_set_timeout(t);  \
-                               MUTEX_EXIT(lck);        \
-                               thread_block();         \
-                               if (isGlockOwner) AFS_GLOCK();  \
-                               MUTEX_ENTER(lck);       \
-                               }
-
-#define CV_SIGNAL(cv)          thread_wakeup_one((vm_offset_t)(cv))
-#define CV_BROADCAST(cv)       thread_wakeup((vm_offset_t)(cv))
-
-typedef struct {
-    simple_lock_data_t lock;
-    thread_t owner;
-} afs_kmutex_t;
-typedef int afs_kcondvar_t;
-
-#define osi_rxWakeup(cv)       thread_wakeup((vm_offset_t)(cv))
-
-#define LOCK_INIT(a,b) \
-    do { \
-       usimple_lock_init(&(a)->lock); \
-       (a)->owner = (thread_t)0; \
-    } while(0);
-#define MUTEX_INIT(a,b,c,d) \
-    do { \
-       usimple_lock_init(&(a)->lock); \
-       (a)->owner = (thread_t)0; \
-    } while(0);
-#define MUTEX_DESTROY(a) \
-    do { \
-       usimple_lock_terminate(&(a)->lock); \
-       (a)->owner = (thread_t)-1; \
-    } while(0);
-#define MUTEX_ENTER(a) \
-    do { \
-       usimple_lock(&(a)->lock); \
-       osi_Assert((a)->owner == (thread_t)0); \
-       (a)->owner = current_thread(); \
-    } while(0);
-#define MUTEX_TRYENTER(a) \
-    ( usimple_lock_try(&(a)->lock) ? ((a)->owner = current_thread(), 1) : 0 )
-#define MUTEX_EXIT(a) \
-    do { \
-       osi_Assert((a)->owner == current_thread()); \
-       (a)->owner = (thread_t)0; \
-       usimple_unlock(&(a)->lock); \
-    } while(0);
-
-#undef MUTEX_ISMINE
-#define MUTEX_ISMINE(a)        (((afs_kmutex_t *)(a))->owner == current_thread())
-
-#undef osirx_AssertMine
-extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg);
-
-#endif /* DUX40 */
-
-
-#endif /* _RX_KMUTEX_H_ */
diff --git a/src/rx/DUX/rx_knet.c b/src/rx/DUX/rx_knet.c
deleted file mode 100644 (file)
index e9d2827..0000000
+++ /dev/null
@@ -1,356 +0,0 @@
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- * 
- * This software has been released under the terms of the IBM Public
- * License.  For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-#include <afsconfig.h>
-#include "afs/param.h"
-
-RCSID
-    ("$Header$");
-
-#ifdef AFS_DUX40_ENV
-#include "rx/rx_kcommon.h"
-
-
-static struct protosw parent_proto;    /* udp proto switch */
-static void rxk_input(struct mbuf *am, int iphlen);
-static void rxk_fasttimo(void);
-
-/* start intercepting basic calls */
-void
-rxk_init()
-{
-    register struct protosw *tpro, *last;
-    if (rxk_initDone)
-       return;
-
-    last = inetdomain.dom_protoswNPROTOSW;
-    for (tpro = inetdomain.dom_protosw; tpro < last; tpro++)
-       if (tpro->pr_protocol == IPPROTO_UDP) {
-           /* force UDP checksumming on for AFS    */
-           extern int udpcksum;
-           udpcksum = 1;
-           memcpy(&parent_proto, tpro, sizeof(parent_proto));
-           tpro->pr_input = rxk_input;
-           tpro->pr_fasttimo = rxk_fasttimo;
-           /*
-            * don't bother with pr_drain and pr_ctlinput
-            * until we have something to do
-            */
-           rxk_initDone = 1;
-           return;
-       }
-    osi_Panic("inet:no udp");
-}
-
-
-static void
-rxk_input(struct mbuf *am, int iphlen)
-{
-    void (*tproc) ();
-    register unsigned short *tsp;
-    int hdr;
-    struct udphdr *tu;
-    register struct ip *ti;
-    struct udpiphdr *tvu;
-    register int i;
-    char *phandle;
-    afs_int32 code;
-    struct sockaddr_in taddr;
-    int tlen;
-    short port;
-    int data_len, comp_sum;
-
-    SPLVAR;
-    NETPRI;
-
-    /* make sure we have base ip and udp headers in first mbuf */
-    if (iphlen > sizeof(struct ip)) {
-       ip_stripoptions(am, NULL, NULL);
-       iphlen = sizeof(struct ip);
-    }
-
-    if (am->m_len < sizeof(struct udpiphdr)) {
-       am = m_pullup(am, sizeof(struct udpiphdr));
-       if (!am) {
-           USERPRI;
-           return;
-       }
-    }
-
-    ti = mtod(am, struct ip *);
-    /* skip basic ip hdr */
-    tu = (struct udphdr *)(((char *)ti) + sizeof(struct ip));
-
-    /* now read the port out */
-    port = tu->uh_dport;
-
-    if (port) {
-       for (tsp = rxk_ports, i = 0; i < MAXRXPORTS; i++) {
-           if (*tsp++ == port) {
-               /* checksum the packet */
-               /*
-                * Make mbuf data length reflect UDP length.
-                * If not enough data to reflect UDP length, drop.
-                */
-               tvu = (struct udpiphdr *)ti;
-               tlen = ntohs((u_short) tvu->ui_ulen);
-               if ((int)ti->ip_len != tlen) {
-                   if (tlen > (int)ti->ip_len) {
-                       m_free(am);
-                       USERPRI;
-                       return;
-                   }
-                   m_adj(am, tlen - (int)ti->ip_len);
-               }
-               /* deliver packet to rx */
-               taddr.sin_family = AF_INET;     /* compute source address */
-               taddr.sin_port = tu->uh_sport;
-               taddr.sin_addr.s_addr = ti->ip_src.s_addr;
-               taddr.sin_len = sizeof(taddr);
-               tvu = (struct udpiphdr *)ti;    /* virtual udp structure, for cksum */
-               /* handle the checksum.  Note that this code damages the actual ip
-                * header (replacing it with the virtual one, which is the same size),
-                * so we must ensure we get everything out we need, first */
-               if (tu->uh_sum != 0) {
-                   /* if the checksum is there, always check it. It's crazy not
-                    * to, unless you can really be sure that your
-                    * underlying network (and interfaces and drivers and
-                    * DMA hardware, etc!) is error-free. First, fill
-                    * in entire virtual ip header. */
-                   tvu->ui_i.fill[0] = 0;
-                   tvu->ui_i.fill[1] = 0;
-                   tvu->ui_x1 = 0;
-                   tvu->ui_len = tvu->ui_ulen;
-                   tlen = ntohs((unsigned short)(tvu->ui_ulen));
-                   if (in_cksum(am, sizeof(struct ip) + tlen)) {
-                       /* checksum, including cksum field, doesn't come out 0, so
-                        * this packet is bad */
-                       m_freem(am);
-                       USERPRI;
-                       return;
-                   }
-               }
-
-               /*
-                * 28 is IP (20) + UDP (8) header.  ulen includes
-                * udp header, and we *don't* tell RX about udp
-                * header either.  So, we remove those 8 as well.
-                */
-               data_len = ntohs(tu->uh_ulen);
-               data_len -= 8;
-               if (!(*rxk_GetPacketProc) (&phandle, data_len)) {
-                   if (rx_mb_to_packet(am, m_freem, 28, data_len, phandle)) {
-                       /* XXX should just increment counter here.. */
-                       printf("rx: truncated UDP packet\n");
-                       rxi_FreePacket(phandle);
-                   } else
-                       (*rxk_PacketArrivalProc) (phandle, &taddr,
-                                                 rxk_portRocks[i], data_len);
-               } else
-                   m_freem(am);
-               USERPRI;
-               return;
-           }
-       }
-    }
-
-    /* if we get here, try to deliver packet to udp */
-    if (tproc = parent_proto.pr_input)
-       (*tproc) (am, iphlen);
-    USERPRI;
-    return;
-}
-
-
-/* 
- * UDP fast timer to raise events for all but Solaris and NCR. 
- * Called about 5 times per second (at unknown priority?).  Must go to
- * splnet or obtain global lock before touching anything significant.
- */
-static void
-rxk_fasttimo(void)
-{
-    void (*tproc) ();
-    struct clock temp;
-
-    /* do rx fasttimo processing here */
-    rxevent_RaiseEvents(&temp);
-    if (tproc = parent_proto.pr_fasttimo)
-       (*tproc) ();
-}
-
-
-/* rx_NetSend - send asize bytes at adata from asocket to host at addr.
- *
- * Now, why do we allocate a new buffer when we could theoretically use the one
- * pointed to by adata?  Because PRU_SEND returns after queueing the message,
- * not after sending it.  If the sender changes the data after queueing it,
- * we'd see the already-queued data change.  One attempt to fix this without
- * adding a copy would be to have this function wait until the datagram is
- * sent; however this doesn't work well.  In particular, if a host is down, and
- * an ARP fails to that host, this packet will be queued until the ARP request
- * comes back, which could be hours later.  We can't block in this routine that
- * long, since it prevents RPC timeouts from happening.
- */
-/* XXX In the brave new world, steal the data bufs out of the rx_packet iovec,
- * and just queue those.  XXX
- */
-
-/* set lock on sockbuf sb; can't call sblock since we're at interrupt level
- * sometimes */
-static
-trysblock(sb)
-     register struct sockbuf *sb;
-{
-    AFS_STATCNT(trysblock);
-    if (sb->sb_flags & SB_LOCK) {
-       return -1;              /* can't lock socket */
-    }
-    sb->sb_flags |= SB_LOCK;
-    return 0;
-}
-
-int
-osi_NetSend(osi_socket asocket, struct sockaddr_in *addr, struct iovec *dvec,
-           int nvec, afs_int32 asize, int istack)
-{
-    register struct mbuf *tm, *um;
-    register afs_int32 code;
-    int s;
-    struct mbuf *top = 0;
-    register struct mbuf *m, **mp;
-    int len;
-    char *tdata;
-    caddr_t tpa;
-    int i, tl, rlen;
-    int mlen;
-    int haveGlock;
-
-    AFS_STATCNT(osi_NetSend);
-
-/* Actually, the Ultrix way is as good as any for us, so we don't bother with
- * special mbufs any more.  Used to think we could get away with not copying
- * the data to the interface, but there's no way to tell the caller not to
- * reuse the buffers after sending, so we lost out on that trick anyway */
-
-    s = splnet();
-    mp = &top;
-    i = 0;
-    tdata = dvec[i].iov_base;
-    tl = dvec[i].iov_len;
-    while (1) {
-       mlen = MLEN;
-       if (top == 0) {
-           MGETHDR(m, M_DONTWAIT, MT_DATA);
-           if (!m) {
-               splx(s);
-               return 1;
-           }
-           mlen = MHLEN;
-           m->m_pkthdr.len = 0;
-           m->m_pkthdr.rcvif = NULL;
-       } else
-           MGET(m, M_DONTWAIT, MT_DATA);
-       if (!m) {
-           /* can't get an mbuf, give up */
-           if (top)
-               m_freem(top);   /* free mbuf list we're building */
-           splx(s);
-           return 1;
-       }
-       /*
-        * WARNING: the `4 * MLEN' is somewhat dubious.  It is better than
-        * `NBPG', which may have no relation to `CLBYTES'.  Also, `CLBYTES'
-        * may be so large that we never use clusters, resulting in far
-        * too many mbufs being used.  It is often better to briefly use
-        * a cluster, even if we are only using a portion of it.  Since
-        * we are on the xmit side, it shouldn't end up sitting on a queue
-        * for a potentially unbounded time (except perhaps if we are talking
-        * to ourself).
-        */
-       if (asize >= 4 * MLEN) {        /* try to get cluster mbuf */
-           register struct mbuf *p;
-
-           /* different algorithms for getting cluster mbuf */
-           MCLGET(m, M_DONTWAIT);
-           if ((m->m_flags & M_EXT) == 0)
-               goto nopages;
-           mlen = MCLBYTES;
-
-           /* now compute usable size */
-           len = MIN(mlen, asize);
-/* Should I look at MAPPED_MBUFS??? */
-       } else {
-         nopages:
-           len = MIN(mlen, asize);
-       }
-       m->m_len = 0;
-       *mp = m;                /* XXXX */
-       top->m_pkthdr.len += len;
-       tpa = mtod(m, caddr_t);
-       while (len) {
-           rlen = MIN(len, tl);
-           memcpy(tpa, tdata, rlen);
-           asize -= rlen;
-           len -= rlen;
-           tpa += rlen;
-           m->m_len += rlen;
-           tdata += rlen;
-           tl -= rlen;
-           if (tl <= 0) {
-               i++;
-               if (i > nvec) {
-                   /* shouldn't come here! */
-                   asize = 0;  /* so we make progress toward completion */
-                   break;
-               }
-               tdata = dvec[i].iov_base;
-               tl = dvec[i].iov_len;
-           }
-       }
-       *mp = m;
-       mp = &m->m_next;
-       if (asize <= 0)
-           break;
-    }
-    tm = top;
-
-    tm->m_act = NULL;
-
-    /* setup mbuf corresponding to destination address */
-    um = m_get(M_DONTWAIT, MT_SONAME);
-    if (!um) {
-       if (top)
-           m_freem(top);       /* free mbuf chain */
-       /* if this were vfs40, we'd do sbunlock(asocket, &asocket->so_snd), but
-        * we don't do the locking at all for vfs40 systems */
-       splx(s);
-       return 1;
-    }
-    memcpy(mtod(um, caddr_t), addr, sizeof(*addr));
-    um->m_len = sizeof(*addr);
-    /* note that udp_usrreq frees funny mbuf.  We hold onto data, but mbuf
-     * around it is gone.  we free address ourselves.  */
-    haveGlock = ISAFS_GLOCK();
-    if (haveGlock) {
-       AFS_GUNLOCK();
-    }
-    SOCKET_LOCK(asocket);
-    code = (*asocket->so_proto->pr_usrreq) (asocket, PRU_SEND, tm, um, 0);
-    SOCKET_UNLOCK(asocket);
-    if (haveGlock) {
-       AFS_GLOCK();
-    }
-    splx(s);
-    m_free(um);
-
-    return code;
-}
-
-#endif /* AFS_DUX40_ENV */