initial-freebsd-port-work-20010414
authorTom Maher <tardis@ece.cmu.edu>
Sat, 14 Apr 2001 18:27:12 +0000 (18:27 +0000)
committerDerrick Brashear <shadow@dementia.org>
Sat, 14 Apr 2001 18:27:12 +0000 (18:27 +0000)
start of work on freebsd port

87 files changed:
src/Makefile
src/afs/FBSD/opt_posix.h [new file with mode: 0644]
src/afs/FBSD/osi_file.c [new file with mode: 0644]
src/afs/FBSD/osi_groups.c [new file with mode: 0644]
src/afs/FBSD/osi_inode.c [new file with mode: 0644]
src/afs/FBSD/osi_inode.h [new file with mode: 0644]
src/afs/FBSD/osi_machdep.h [new file with mode: 0644]
src/afs/FBSD/osi_misc.c [new file with mode: 0644]
src/afs/FBSD/osi_sleep.c [new file with mode: 0644]
src/afs/FBSD/osi_vfsops.c [new file with mode: 0644]
src/afs/FBSD/osi_vm.c [new file with mode: 0644]
src/afs/FBSD/osi_vnodeops.c [new file with mode: 0644]
src/afs/FBSD/vnode_if.h [new file with mode: 0644]
src/afs/Makefile
src/afs/UKERNEL/afs_usrops.c
src/afs/UKERNEL/sysincludes.h
src/afs/VNOPS/afs_vnop_attrs.c
src/afs/VNOPS/afs_vnop_flock.c
src/afs/VNOPS/afs_vnop_strategy.c
src/afs/VNOPS/afs_vnop_write.c
src/afs/afs.h
src/afs/afs_analyze.c
src/afs/afs_call.c
src/afs/afs_dcache.c
src/afs/afs_init.c
src/afs/afs_osi.c
src/afs/afs_osi.h
src/afs/afs_osi_pag.c
src/afs/afs_prototypes.h
src/afs/afs_server.c
src/afs/afs_user.c
src/afs/afsincludes.h
src/afs/exporter.h
src/afs/lock.h
src/afs/sysincludes.h
src/afsd/Makefile
src/afsd/afs.rc.fbsd [new file with mode: 0644]
src/afsd/afsd.c
src/afsmonitor/afsmonitor.c
src/config/Makefile.i386_fbsd_42 [new file with mode: 0644]
src/config/afs_sysnames.h
src/config/param.i386_fbsd_42.h [new file with mode: 0644]
src/config/param.i386_fbsd_42_usr.h [new file with mode: 0644]
src/des/read_pssword.c
src/dir/dir.c
src/kauth/kaserver.c
src/kauth/klogin.c
src/kauth/user.c
src/libafs/MakefileProto.FBSD [new file with mode: 0644]
src/libafsrpc/Makefile
src/libuafs/MakefileProto.FBSD [new file with mode: 0644]
src/login/login.c
src/lwp/Makefile
src/lwp/lwp.c
src/lwp/preempt.c
src/lwp/process.c
src/lwp/process.fbsd.s [new file with mode: 0644]
src/lwp/timer.c
src/lwp/waitkey.c
src/package/gram.y
src/package/test_gram.y
src/pam/Makefile
src/pam/test_pam.c
src/pinstall/install.c
src/rcp/rcp.c
src/rsh/rcmd.c
src/rx/FBSD/rx_kmutex.h [new file with mode: 0644]
src/rx/FBSD/rx_knet.c [new file with mode: 0644]
src/rx/Makefile
src/rx/rx_getaddr.c
src/rx/rx_kcommon.c
src/rx/rx_kcommon.h
src/rx/rx_packet.h
src/rx/rx_rdwr.c
src/rxgen/rpc_main.c
src/sys/Makefile
src/uss/uss_common.h
src/util/netutils.c
src/venus/kdump.c
src/venus/up.c
src/viced/afsfileprocs.c
src/vol/Makefile
src/vol/devname.c
src/vol/listinodes.c
src/vol/partition.c
src/vol/vol-salvage.c
src/vol/volume.c

index fcee729..822cdd6 100644 (file)
@@ -202,7 +202,7 @@ null: project
 
 gtx: project null auth # kauth rxkad ?
        case ${SYS_NAME} in \
-         rs_aix* | sun4x_5? | sgi_6? | *linux* | ppc_darwin*) \
+         rs_aix* | sun4x_5? | sgi_6? | *linux* | ppc_darwin* | *fbsd*) \
                rm -f ${DESTDIR}lib/afs/libtermlib.a; \
                ln -s libnull.a ${DESTDIR}lib/afs/libtermlib.a; \
                ${COMPILE_PART1} gtx ${COMPILE_PART2};; \
@@ -234,7 +234,7 @@ ntp: project volser
        case ${SYS_NAME} in \
          sun4x_58 ) echo skipping ntp for ${SYS_NAME} ;; \
          *linux* ) echo skipping ntp for ${SYS_NAME} ;; \
-         ppc_darwin* ) echo skipping ntp for ${SYS_NAME} ;; \
+         ppc_darwin* | *fbsd* ) echo skipping ntp for ${SYS_NAME} ;; \
          * ) ${COMPILE_PART1} ntp ${COMPILE_PART2} ;; \
        esac
 
@@ -253,7 +253,7 @@ bozo: project ntp audit
 vfsck: minproject vol
        set -x; \
        case ${SYS_NAME} in \
-       sgi_* | *linux* | rs_aix42 | ppc_darwin* | hp_ux* ) \
+       sgi_* | *linux* | rs_aix42 | ppc_darwin* | hp_ux* | *fbsd* ) \
                echo skip vfsck for ${SYS_NAME} ;; \
         * ) \
                ${COMPILE_PART1} vfsck ${COMPILE_PART2} ;; \
@@ -271,7 +271,7 @@ login: project kauth rxkad
                ${COMPILE_PART1} sia ${COMPILE_PART2} ;; \
        sun4x_55 ) \
                 ${COMPILE_PART1} login ${COMPILE_PART2} ;; \
-       sun4x_* | hp_ux11* | *linux* ) \
+       sun4x_* | hp_ux11* | *linux* | *fbsd* ) \
                ${COMPILE_PART1} pam ${COMPILE_PART2} ;; \
        ppc_darwin* ) \
                echo Skipping login for ${SYS_NAME} ;; \
@@ -479,6 +479,8 @@ libafs_setup: config minproject export
                MKAFS_OSTYPE=HPUX;; \
        *linux*) \
                MKAFS_OSTYPE=LINUX;; \
+       *fbsd*) \
+               MKAFS_OSTYPE=FBSD;; \
        rs_aix* ) \
                MKAFS_OSTYPE=AIX;; \
        sgi_* ) \
@@ -502,6 +504,8 @@ libuafs_setup: config minproject export
                MKAFS_OSTYPE=HPUX;; \
        *linux*) \
                MKAFS_OSTYPE=LINUX;; \
+       *fbsd*) \
+               MKAFS_OSTYPE=FBSD;; \
        rs_aix* ) \
                MKAFS_OSTYPE=AIX;; \
        sun4x_5* ) \
diff --git a/src/afs/FBSD/opt_posix.h b/src/afs/FBSD/opt_posix.h
new file mode 100644 (file)
index 0000000..0215c63
--- /dev/null
@@ -0,0 +1,2 @@
+#define P1003_1B 1
+#define _KPOSIX_PRIORITY_SCHEDULING 1
diff --git a/src/afs/FBSD/osi_file.c b/src/afs/FBSD/osi_file.c
new file mode 100644 (file)
index 0000000..ba711ae
--- /dev/null
@@ -0,0 +1,234 @@
+/*
+ * 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 "../afs/param.h"      /* Should be always first */
+#include "../afs/sysincludes.h"        /* Standard vendor system headers */
+#include "../afs/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(ainode)
+    afs_int32 ainode;
+{
+    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");
+    }
+    if (!afs_osicred_initialized) {
+       /* valid for alpha_osf, SunOS, Ultrix */
+       bzero((char *)&afs_osi_cred, sizeof(struct AFS_UCRED));
+       afs_osi_cred.cr_ref++;
+       afs_osicred_initialized = 1;
+    }
+    afile = (struct osi_file *) osi_AllocSmallSpace(sizeof(struct osi_file));
+    AFS_GUNLOCK();
+    code = igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, (ino_t)ainode, &ip, &dummy);
+    AFS_GLOCK();
+    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 = (int (*)()) 0;
+    afile->inum = ainode;        /* for hint validity checking */
+    return (void *)afile;
+}
+
+afs_osi_Stat(afile, astat)
+    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;
+}
+
+osi_UFSClose(afile)
+     register struct osi_file *afile;
+  {
+      AFS_STATCNT(osi_Close);
+      if(afile->vnode) {
+       AFS_RELE(afile->vnode);
+      }
+      
+      osi_FreeSmallSpace(afile);
+      return 0;
+  }
+
+osi_UFSTruncate(afile, asize)
+    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 cred instead of to
+       credentials parameter.  Probably should fix ufs some day. */
+    oldCred = curproc->p_cred->pc_ucred; /* remember old credentials pointer  */
+    curproc->p_cred->pc_ucred = &afs_osi_cred;
+    /* temporarily use superuser credentials */
+    tvattr.va_size = asize;
+    AFS_GUNLOCK();
+    VOP_SETATTR(afile->vnode, &tvattr, &afs_osi_cred, code);
+    AFS_GLOCK();
+    curproc->p_cred->pc_ucred = oldCred;     /* restore */
+    MReleaseWriteLock(&afs_xosi);
+    return code;
+}
+
+void osi_DisableAtimes(avp)
+struct vnode *avp;
+{
+   struct inode *ip = VTOI(avp);
+   ip->i_flag &= ~IACC;
+}
+
+
+/* Generic read interface */
+afs_osi_Read(afile, offset, aptr, asize)
+    register struct osi_file *afile;
+    int offset;
+    char *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 */
+afs_osi_Write(afile, offset, aptr, asize)
+    register struct osi_file *afile;
+    char *aptr;
+    afs_int32 offset;
+    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 = curproc->p_cred->pc_ucred;
+       curproc->p_cred->pc_ucred = &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();
+       curproc->p_cred->pc_ucred = 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(aproc, bp)
+       int (*aproc)();
+       register struct buf *bp;
+{
+    afs_int32 returnCode;
+
+    AFS_STATCNT(osi_MapStrategy);
+    returnCode = (*aproc) (bp);
+
+    return returnCode;
+}
+
+
+
+void
+shutdown_osifile()
+{
+  extern int afs_cold_shutdown;
+
+  AFS_STATCNT(shutdown_osifile);
+  if (afs_cold_shutdown) {
+    afs_osicred_initialized = 0;
+  }
+}
+
diff --git a/src/afs/FBSD/osi_groups.c b/src/afs/FBSD/osi_groups.c
new file mode 100644 (file)
index 0000000..6e3ef48
--- /dev/null
@@ -0,0 +1,160 @@
+/*
+ * 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_groups.c
+ *
+ * Implements:
+ * Afs_xsetgroups (syscall)
+ * setpag
+ *
+ */
+#include "../afs/param.h"
+#include "../afs/sysincludes.h"
+#include "../afs/afsincludes.h"
+#include "../afs/afs_stats.h"  /* statistics */
+
+#define NOCRED  ((struct ucred *) -1)
+#define NOUID   ((uid_t) -1)
+#define NOGID   ((gid_t) -1)
+
+
+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); */
+    code = afs_InitReq(&treq, curproc->p_cred->pc_ucred);
+    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(curproc->p_cred->pc_ucred) == 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/FBSD/osi_inode.c b/src/afs/FBSD/osi_inode.c
new file mode 100644 (file)
index 0000000..1c4fc66
--- /dev/null
@@ -0,0 +1,279 @@
+/*
+ * 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
+ */
+
+/*
+ * FreeBSD inode operations
+ *
+ * Implements:
+ *
+ */
+#include "../afs/param.h"      /* Should be always first */
+#include "../afs/sysincludes.h"        /* Standard vendor system headers */
+#include "../afs/afsincludes.h"        /* Afs-based standard headers */
+#include "../afs/osi_inode.h"
+#include "../afs/afs_stats.h" /* statistics stuff */
+#include <sys/queue.h>
+#include <sys/lock.h>
+#include <ufs/ufsmount.h>
+#include <ufs/ufs/dinode.h>
+
+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 = TAILQ_FIRST(&mountlist)) do {
+           /*
+            * XXX Also do the test for MFS 
+            */
+#undef m_data
+#undef m_next
+           if (mp->mnt_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();
+           }
+           mp = TAILQ_NEXT(mp, mnt_list);
+       } while (mp != TAILQ_FIRST(&mountlist));
+       MOUNTLIST_UNLOCK();
+       if (!fs)
+           return(ENXIO);
+    }
+    vp = (struct vnode *) fake_vnode;
+    fake_inode_init(vp, fs);
+    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())
+       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 = (struct vnode *)0;
+    int dummy;
+    int fd;
+    extern struct fileops vnops;
+    register int code;
+    
+    AFS_STATCNT(afs_syscall_iopen);
+    
+    if (!afs_suser())
+       return(EPERM);
+
+    code = igetinode(0, (dev_t)dev, (ino_t)inode, &ip, &dummy);
+    if (code) {
+       return(code);
+    }
+    if ((code = falloc(curproc, &fp, &fd)) != 0) {
+       iput(ip);
+       return(code);
+    }
+    IN_UNLOCK(ip);
+    
+    /* FreeBSD doesn't do much mp stuff yet :( */
+    /* FP_LOCK(fp); */
+    fp->f_flag = (usrmod) & FMASK;
+    fp->f_type = DTYPE_VNODE;
+    fp->f_ops = &vnops;
+    fp->f_data = (caddr_t)ITOV(ip);
+    
+    /* FP_UNLOCK(fp); */
+    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())
+       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/FBSD/osi_inode.h b/src/afs/FBSD/osi_inode.h
new file mode 100644 (file)
index 0000000..39c706f
--- /dev/null
@@ -0,0 +1,70 @@
+/*
+ * 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_inode.h
+ *
+ * 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 FAKE_INODE_SIZE    (sizeof(struct vnode)+sizeof(struct inode))
+#define MOUNTLIST_UNLOCK() simple_lock_unlock(&mountlist_slock)
+#define MOUNTLIST_LOCK()   simple_lock(&mountlist_slock)
+
+/* FreeBSD doesn't actually have a di_proplb, so we use di_spare[0] */
+#define di_proplb       di_spare[0]
+/* For some reason, they're called "oldids" instead of "bc_{u,g}id" */
+#define di_bcuid        di_u.oldids[0]
+#define di_bcgid        di_u.oldids[1]
+
+#define i_vicemagic    i_din.di_spare[0]
+#define i_vicep1       i_din.di_uid
+#define i_vicep2       i_din.di_gid
+#define i_vicep3a      i_din.di_u.oldids[0]
+#define i_vicep3b      i_din.di_u.oldids[1]
+#define i_vicep4       i_din.di_spare[1]       /* not used */
+
+#define di_vicemagic   di_spare[0]
+#define di_vicep1      di_uid
+#define di_vicep2      di_gid
+#define di_vicep3a     di_u.oldids[0]
+#define di_vicep3b     di_u.oldids[1]
+#define di_vicep4      di_spare[1]             /* not used */
+
+/*
+ * Macros for handling inode numbers:
+ *     inode number to file system block offset.
+ *     inode number to cylinder group number.
+ *     inode number to file system block address.
+ */
+#define itoo(fs, x)     ((x) % INOPB(fs))
+#define itog(fs, x)     ((x) / (fs)->fs_ipg)
+#define itod(fs, x) \
+        ((daddr_t)(cgimin(fs, itog(fs, x)) + \
+        (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))
+
+
+#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/FBSD/osi_machdep.h b/src/afs/FBSD/osi_machdep.h
new file mode 100644 (file)
index 0000000..b0c0442
--- /dev/null
@@ -0,0 +1,91 @@
+/*
+ * 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 <sys/lock.h>
+/* #include <kern/sched_prim.h> */
+/* #include <sys/unix_defs.h> */
+
+#define getpid()               curproc
+extern struct simplelock afs_rxglobal_lock;
+
+/* 
+ * 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((struct vnode *)(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), curproc)
+
+#undef afs_suser
+
+#ifdef KERNEL
+extern struct simplelock afs_global_lock;
+#if 0
+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())
+#else
+#define AFS_GLOCK() \
+    do { \
+       simple_lock(&afs_global_lock); \
+    } while (0)
+#define AFS_GUNLOCK() \
+    do { \
+       simple_unlock(&afs_global_lock); \
+    } while(0)
+#endif /* 0 */
+#define AFS_RXGLOCK()
+#define AFS_RXGUNLOCK()
+#define ISAFS_RXGLOCK() 1
+
+#undef SPLVAR
+#define SPLVAR
+#undef NETPRI
+#define NETPRI
+#undef USERPRI
+#define USERPRI
+#endif /* KERNEL */
+
+#endif /* _OSI_MACHDEP_H_ */
diff --git a/src/afs/FBSD/osi_misc.c b/src/afs/FBSD/osi_misc.c
new file mode 100644 (file)
index 0000000..00d91cf
--- /dev/null
@@ -0,0 +1,34 @@
+/*
+ * 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_misc.c
+ *
+ * Implements:
+ * afs_suser
+ */
+
+#include "../afs/param.h"      /* Should be always first */
+#include "../afs/sysincludes.h"        /* Standard vendor system headers */
+#include "../afs/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() {
+    int error;
+
+    if (suser(curproc) == 0) {
+       return(1);
+    }
+    return(0);
+}
diff --git a/src/afs/FBSD/osi_sleep.c b/src/afs/FBSD/osi_sleep.c
new file mode 100644 (file)
index 0000000..84bd0be
--- /dev/null
@@ -0,0 +1,184 @@
+/*
+ * 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 "../afs/param.h"      /* Should be always first */
+#include "../afs/sysincludes.h"        /* Standard vendor system headers */
+#include "../afs/afsincludes.h"        /* Afs-based standard headers */
+#include "../afs/afs_stats.h"   /* afs statistics */
+
+
+
+static int osi_TimedSleep(char *event, afs_int32 ams, int aintok);
+void afs_osi_Wakeup(char *event);
+void afs_osi_Sleep(char *event);
+
+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) curproc;
+    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(char *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);
+}
+
+/* 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;
+}
+
+
+void afs_osi_Wakeup(char *event)
+{
+    struct afs_event *evp;
+
+    evp = afs_getevent(event);
+    if (evp->refcount > 1) {
+       evp->seq++;    
+       thread_wakeup((vm_offset_t)(&evp->cond));
+    }
+    relevent(evp);
+}
diff --git a/src/afs/FBSD/osi_vfsops.c b/src/afs/FBSD/osi_vfsops.c
new file mode 100644 (file)
index 0000000..a87c70b
--- /dev/null
@@ -0,0 +1,481 @@
+/*
+ * 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 "../afs/param.h"      /* Should be always first */
+#include "../afs/sysincludes.h"        /* Standard vendor system headers */
+#include "../afs/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");
+
+    bzero(afsp->m_stat.f_mntonname, MNAMELEN);
+    bzero(afsp->m_stat.f_mntfromname, MNAMELEN);
+    AFS_COPYINSTR(path, (caddr_t)afsp->m_stat.f_mntonname, MNAMELEN, &size, code);
+    bcopy("AFS", afsp->m_stat.f_mntfromname, 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 (!(code = afs_InitReq(&treq, cred)) &&
+           !(code = afs_CheckInit())) {
+           tvp = afs_GetVCache(&afs_rootFid, &treq, (afs_int32 *)0,
+                               (struct vcache*)0, WRITE_LOCK);
+           /* we really want this to stay around */
+           if (tvp) {
+               afs_globalVp = tvp;
+           } else
+               code = ENOENT;
+       }
+    }
+    if (tvp) {
+       AFS_GUNLOCK();
+       VN_HOLD((struct vnode *)tvp);
+       VN_LOCK((struct vnode *)tvp);
+       tvp->v.v_flag |= VROOT;     /* No-op on Ultrix 2.2 */
+       VN_UNLOCK((struct vnode *)tvp);
+       AFS_GLOCK();
+
+       afs_globalVFS = afsp;
+       *avpp = (struct vnode *) tvp;
+    }
+
+    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;
+}
+
+
+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, 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 = (struct vcache *)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((struct vnode *)avc);
+       AFS_GLOCK();
+    }
+
+    /* Use the fid pointer passed to us. */
+    fidp->fid_len = AFS_SIZEOFSMALLFID;
+    if (afs_NFSRootOnly) {
+       if (rootvp) {
+           bcopy((caddr_t)&Sfid, fidp->fid_data, AFS_FIDDATASIZE);   
+       } else {
+           bcopy((caddr_t)addr, fidp->fid_data, AFS_FIDDATASIZE);   
+       }
+    } else {
+       bcopy((caddr_t)&Sfid, fidp->fid_data, 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
+};
+
+
+/*
+ * 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();
+    sysent[AFS_SYSCALL].sy_call = afs3_syscall;
+    sysent[AFS_SYSCALL].sy_parallel = 0;
+    sysent[AFS_SYSCALL].sy_narg = 6;
+    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/FBSD/osi_vm.c b/src/afs/FBSD/osi_vm.c
new file mode 100644 (file)
index 0000000..6d29231
--- /dev/null
@@ -0,0 +1,210 @@
+/*
+ * 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_vm.c implements:
+ *
+ * osi_VM_FlushVCache(avc, slept)
+ * osi_ubc_flush_dirty_and_wait(vp, flags)
+ * osi_VM_StoreAllSegments(avc)
+ * osi_VM_TryToSmush(avc, acred, sync)
+ * osi_VM_FlushPages(avc, credp)
+ * osi_VM_Truncate(avc, alen, acred)
+ */
+
+#include "../afs/param.h"      /* Should be always first */
+#include "../afs/sysincludes.h"        /* Standard vendor system headers */
+#include "../afs/afsincludes.h"        /* Afs-based standard headers */
+#include "../afs/afs_stats.h"  /* statistics */
+/* #include <vm/vm_ubc.h> */
+#include <limits.h>
+#include <float.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(avc, slept)
+    struct vcache *avc;
+    int *slept;
+{
+#ifdef SECRETLY_OSF1
+    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(((struct vnode *)avc)->v_object, 0, 0, B_INVAL);
+    AFS_GLOCK();
+#endif /* SECRETLY_OSF1 */
+
+    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.
+ */
+void
+osi_ubc_flush_dirty_and_wait(vp, flags)
+struct vnode *vp;
+int flags; {
+    int retry;
+    vm_page_t pp;
+    int first;
+
+#ifdef SECRETLY_OSF1
+    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);
+#endif /* SECRETLY_OSF1 */
+}
+
+/* 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(avc)
+    struct vcache *avc;
+{
+#ifdef SECRETLY_OSF1
+    ReleaseWriteLock(&avc->lock);
+    AFS_GUNLOCK();
+    osi_ubc_flush_dirty_and_wait((struct vnode *)avc, 0);
+    AFS_GLOCK();
+    ObtainWriteLock(&avc->lock,94);
+#endif /* SECRETLY_OSF1 */
+}
+
+/* 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(avc, acred, sync)
+    struct vcache *avc;
+    struct AFS_UCRED *acred;
+    int sync;
+{
+#ifdef SECRETLY_OSF1
+    ReleaseWriteLock(&avc->lock);
+    AFS_GUNLOCK();
+    osi_ubc_flush_dirty_and_wait((struct vnode *)avc, 0);
+    ubc_invalidate(((struct vnode *)avc)->v_object, 0, 0, B_INVAL);
+    AFS_GLOCK();
+    ObtainWriteLock(&avc->lock,59);
+#endif /* SECRETLY_OSF1 */
+}
+
+/* Purge VM for a file when its callback is revoked.
+ *
+ * Locking:  No lock is held, not even the global lock.
+ */
+void
+osi_VM_FlushPages(avc, credp)
+    struct vcache *avc;
+    struct AFS_UCRED *credp;
+{
+#ifdef SECRETLY_OSF1
+    ubc_flush_dirty(((struct vnode *)avc)->v_object, 0);
+    ubc_invalidate(((struct vnode *)avc)->v_object, 0, 0, B_INVAL);
+#endif /* SECRETLY_OSF1 */
+}
+
+/* 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(avc, alen, acred)
+    struct vcache *avc;
+    int alen;
+    struct AFS_UCRED *acred;
+{
+#ifdef SECRETLY_OSF1
+    ubc_invalidate(((struct vnode *)avc)->v_object, alen,
+                        MAXINT - alen, B_INVAL);
+#endif /* SECRETLY_OSF1 */
+}
diff --git a/src/afs/FBSD/osi_vnodeops.c b/src/afs/FBSD/osi_vnodeops.c
new file mode 100644 (file)
index 0000000..617d6a0
--- /dev/null
@@ -0,0 +1,1091 @@
+/*
+ * 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 "../afs/param.h"      /* Should be always first */
+
+#include "../afs/sysincludes.h"        /* Standard vendor system headers */
+#include "../afs/afsincludes.h"        /* Afs-based standard headers */
+#include "../afs/afs_stats.h" /* statistics */
+#include <vm/vm.h>
+#include <vm/vnode_pager.h>
+#include <vm/vm_map.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();
+
+#if 0
+/* 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,
+       afs_badop,      /* 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;
+#endif /* 0 */
+
+/* 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,
+};
+
+#if 0
+mp_afs_lookup(adp, ndp)
+    struct vcache *adp;
+    struct nameidata *ndp;
+{
+    int code;
+    AFS_GLOCK();
+    code = afs_lookup(adp, ndp);
+    AFS_GUNLOCK();
+    return code;
+}
+
+mp_afs_create(ndp, attrs)
+    struct nameidata *ndp;
+    struct vattr *attrs;
+{
+    int code;
+    AFS_GLOCK();
+    code = afs_create(ndp, attrs);
+    AFS_GUNLOCK();
+    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;
+    AFS_GLOCK();
+    code = afs_remove(ndp);
+    AFS_GUNLOCK();
+    return code;
+}
+
+mp_afs_link(avc, ndp)
+    struct vcache *avc;
+    struct nameidata *ndp;
+{
+    int code;
+    AFS_GLOCK();
+    code = afs_link(avc, ndp);
+    AFS_GUNLOCK();
+    return code;
+}
+
+mp_afs_rename(fndp, tndp)
+    struct nameidata *fndp, *tndp;
+{
+    int code;
+    AFS_GLOCK();
+    code = afs_rename(fndp, tndp);
+    AFS_GUNLOCK();
+    return code;
+}
+
+mp_afs_mkdir(ndp, attrs)
+    struct nameidata *ndp;
+    struct vattr *attrs;
+{
+    int code;
+    AFS_GLOCK();
+    code = afs_mkdir(ndp, attrs);
+    AFS_GUNLOCK();
+    return code;
+}
+
+mp_afs_rmdir(ndp)
+    struct nameidata *ndp;
+{
+    int code;
+    AFS_GLOCK();
+    code = afs_rmdir(ndp);
+    AFS_GUNLOCK();
+    return code;
+}
+
+mp_afs_symlink(ndp, attrs, atargetName)
+    struct nameidata *ndp;
+    struct vattr *attrs;
+    register char *atargetName;
+{
+    int code;
+    AFS_GLOCK();
+    code = afs_symlink(ndp, attrs, atargetName);
+    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) == 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);       /* 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();
+       code = ubc_lookup(((struct vnode *)avc)->v_object, pageBase,
+                         PAGE_SIZE, PAGE_SIZE, &page, &flags);
+       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 = (struct vnode *)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 = (struct vnode *)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 = (char *)page->pg_addr; /* DUX 4.0D */
+       if (data == 0)
+            data = (char *)PHYS_TO_KSEG(page->pg_phys_addr);  /* DUX 4.0E */
+       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(((struct vnode *)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 = (struct vnode *)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->flags & 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(((struct vnode *)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;
+}
+
+
+/*
+ * 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 = (struct vnode *)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);       /* 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, mape, addr, 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;
+    vm_map_entry_t mape;
+    vm_offset_t addr;
+    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 =  (struct vcache *)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();
+       code = ubc_lookup(((struct vnode *)avc)->v_object, off,
+                       PAGE_SIZE, PAGE_SIZE, pagep, &flags);
+       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 = (struct vnode *)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 = (struct vnode *)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();
+           ubc_page_dirty(pl[i]);
+           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 vcache *avc = (struct vcache *)vop->vu_vp;
+    struct vnode *vp = (struct vnode *)avc;
+    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 = (struct vnode *)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((struct vcache *)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;
+}
+
+
+
+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 */
+};
+#endif /* 0 */
+
+/*
+ * 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 != (struct vnode **)0)
+       *dvpp = ndp->ni_dvp;
+    if (cvpp != (struct vnode **)0)
+       *cvpp = ndp->ni_vp;
+    return(error);
+}
+
diff --git a/src/afs/FBSD/vnode_if.h b/src/afs/FBSD/vnode_if.h
new file mode 100644 (file)
index 0000000..7c4da8f
--- /dev/null
@@ -0,0 +1,1348 @@
+/*
+ * 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
+ */
+
+/*
+ * This file is produced automatically.
+ * Do not modify anything in here by hand.
+ *
+ * Created from @(#)vnode_if.sh        8.1 (Berkeley) 6/10/93
+ */
+
+extern struct vnodeop_desc vop_default_desc;
+struct vop_islocked_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_islocked_desc;
+static __inline int VOP_ISLOCKED __P((
+       struct vnode *vp,
+       struct proc *p));
+static __inline int VOP_ISLOCKED(vp, p)
+       struct vnode *vp;
+       struct proc *p;
+{
+       struct vop_islocked_args a;
+       int rc;
+       a.a_desc = VDESC(vop_islocked);
+       a.a_vp = vp;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_islocked), &a);
+       return (rc);
+}
+struct vop_lookup_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_dvp;
+       struct vnode **a_vpp;
+       struct componentname *a_cnp;
+};
+extern struct vnodeop_desc vop_lookup_desc;
+static __inline int VOP_LOOKUP __P((
+       struct vnode *dvp,
+       struct vnode **vpp,
+       struct componentname *cnp));
+static __inline int VOP_LOOKUP(dvp, vpp, cnp)
+       struct vnode *dvp;
+       struct vnode **vpp;
+       struct componentname *cnp;
+{
+       struct vop_lookup_args a;
+       int rc;
+       a.a_desc = VDESC(vop_lookup);
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = cnp;
+       rc = VCALL(dvp, VOFFSET(vop_lookup), &a);
+       return (rc);
+}
+struct vop_cachedlookup_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_dvp;
+       struct vnode **a_vpp;
+       struct componentname *a_cnp;
+};
+extern struct vnodeop_desc vop_cachedlookup_desc;
+static __inline int VOP_CACHEDLOOKUP __P((
+       struct vnode *dvp,
+       struct vnode **vpp,
+       struct componentname *cnp));
+static __inline int VOP_CACHEDLOOKUP(dvp, vpp, cnp)
+       struct vnode *dvp;
+       struct vnode **vpp;
+       struct componentname *cnp;
+{
+       struct vop_cachedlookup_args a;
+       int rc;
+       a.a_desc = VDESC(vop_cachedlookup);
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = cnp;
+       rc = VCALL(dvp, VOFFSET(vop_cachedlookup), &a);
+       return (rc);
+}
+struct vop_create_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_dvp;
+       struct vnode **a_vpp;
+       struct componentname *a_cnp;
+       struct vattr *a_vap;
+};
+extern struct vnodeop_desc vop_create_desc;
+static __inline int VOP_CREATE __P((
+       struct vnode *dvp,
+       struct vnode **vpp,
+       struct componentname *cnp,
+       struct vattr *vap));
+static __inline int VOP_CREATE(dvp, vpp, cnp, vap)
+       struct vnode *dvp;
+       struct vnode **vpp;
+       struct componentname *cnp;
+       struct vattr *vap;
+{
+       struct vop_create_args a;
+       int rc;
+       a.a_desc = VDESC(vop_create);
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = cnp;
+       a.a_vap = vap;
+       rc = VCALL(dvp, VOFFSET(vop_create), &a);
+       return (rc);
+}
+struct vop_whiteout_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_dvp;
+       struct componentname *a_cnp;
+       int a_flags;
+};
+extern struct vnodeop_desc vop_whiteout_desc;
+static __inline int VOP_WHITEOUT __P((
+       struct vnode *dvp,
+       struct componentname *cnp,
+       int flags));
+static __inline int VOP_WHITEOUT(dvp, cnp, flags)
+       struct vnode *dvp;
+       struct componentname *cnp;
+       int flags;
+{
+       struct vop_whiteout_args a;
+       int rc;
+       a.a_desc = VDESC(vop_whiteout);
+       a.a_dvp = dvp;
+       a.a_cnp = cnp;
+       a.a_flags = flags;
+       rc = VCALL(dvp, VOFFSET(vop_whiteout), &a);
+       return (rc);
+}
+struct vop_mknod_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_dvp;
+       struct vnode **a_vpp;
+       struct componentname *a_cnp;
+       struct vattr *a_vap;
+};
+extern struct vnodeop_desc vop_mknod_desc;
+static __inline int VOP_MKNOD __P((
+       struct vnode *dvp,
+       struct vnode **vpp,
+       struct componentname *cnp,
+       struct vattr *vap));
+static __inline int VOP_MKNOD(dvp, vpp, cnp, vap)
+       struct vnode *dvp;
+       struct vnode **vpp;
+       struct componentname *cnp;
+       struct vattr *vap;
+{
+       struct vop_mknod_args a;
+       int rc;
+       a.a_desc = VDESC(vop_mknod);
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = cnp;
+       a.a_vap = vap;
+       rc = VCALL(dvp, VOFFSET(vop_mknod), &a);
+       return (rc);
+}
+struct vop_open_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       int a_mode;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_open_desc;
+static __inline int VOP_OPEN __P((
+       struct vnode *vp,
+       int mode,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_OPEN(vp, mode, cred, p)
+       struct vnode *vp;
+       int mode;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_open_args a;
+       int rc;
+       a.a_desc = VDESC(vop_open);
+       a.a_vp = vp;
+       a.a_mode = mode;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_open), &a);
+       return (rc);
+}
+struct vop_close_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       int a_fflag;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_close_desc;
+static __inline int VOP_CLOSE __P((
+       struct vnode *vp,
+       int fflag,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_CLOSE(vp, fflag, cred, p)
+       struct vnode *vp;
+       int fflag;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_close_args a;
+       int rc;
+       a.a_desc = VDESC(vop_close);
+       a.a_vp = vp;
+       a.a_fflag = fflag;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_close), &a);
+       return (rc);
+}
+struct vop_access_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       int a_mode;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_access_desc;
+static __inline int VOP_ACCESS __P((
+       struct vnode *vp,
+       int mode,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_ACCESS(vp, mode, cred, p)
+       struct vnode *vp;
+       int mode;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_access_args a;
+       int rc;
+       a.a_desc = VDESC(vop_access);
+       a.a_vp = vp;
+       a.a_mode = mode;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_access), &a);
+       return (rc);
+}
+struct vop_getattr_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct vattr *a_vap;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_getattr_desc;
+static __inline int VOP_GETATTR __P((
+       struct vnode *vp,
+       struct vattr *vap,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_GETATTR(vp, vap, cred, p)
+       struct vnode *vp;
+       struct vattr *vap;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_getattr_args a;
+       int rc;
+       a.a_desc = VDESC(vop_getattr);
+       a.a_vp = vp;
+       a.a_vap = vap;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_getattr), &a);
+       return (rc);
+}
+struct vop_setattr_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct vattr *a_vap;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_setattr_desc;
+static __inline int VOP_SETATTR __P((
+       struct vnode *vp,
+       struct vattr *vap,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_SETATTR(vp, vap, cred, p)
+       struct vnode *vp;
+       struct vattr *vap;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_setattr_args a;
+       int rc;
+       a.a_desc = VDESC(vop_setattr);
+       a.a_vp = vp;
+       a.a_vap = vap;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_setattr), &a);
+       return (rc);
+}
+struct vop_read_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct uio *a_uio;
+       int a_ioflag;
+       struct ucred *a_cred;
+};
+extern struct vnodeop_desc vop_read_desc;
+static __inline int VOP_READ __P((
+       struct vnode *vp,
+       struct uio *uio,
+       int ioflag,
+       struct ucred *cred));
+static __inline int VOP_READ(vp, uio, ioflag, cred)
+       struct vnode *vp;
+       struct uio *uio;
+       int ioflag;
+       struct ucred *cred;
+{
+       struct vop_read_args a;
+       int rc;
+       a.a_desc = VDESC(vop_read);
+       a.a_vp = vp;
+       a.a_uio = uio;
+       a.a_ioflag = ioflag;
+       a.a_cred = cred;
+       rc = VCALL(vp, VOFFSET(vop_read), &a);
+       return (rc);
+}
+struct vop_write_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct uio *a_uio;
+       int a_ioflag;
+       struct ucred *a_cred;
+};
+extern struct vnodeop_desc vop_write_desc;
+static __inline int VOP_WRITE __P((
+       struct vnode *vp,
+       struct uio *uio,
+       int ioflag,
+       struct ucred *cred));
+static __inline int VOP_WRITE(vp, uio, ioflag, cred)
+       struct vnode *vp;
+       struct uio *uio;
+       int ioflag;
+       struct ucred *cred;
+{
+       struct vop_write_args a;
+       int rc;
+       a.a_desc = VDESC(vop_write);
+       a.a_vp = vp;
+       a.a_uio = uio;
+       a.a_ioflag = ioflag;
+       a.a_cred = cred;
+       rc = VCALL(vp, VOFFSET(vop_write), &a);
+       return (rc);
+}
+struct vop_lease_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct proc *a_p;
+       struct ucred *a_cred;
+       int a_flag;
+};
+extern struct vnodeop_desc vop_lease_desc;
+static __inline int VOP_LEASE __P((
+       struct vnode *vp,
+       struct proc *p,
+       struct ucred *cred,
+       int flag));
+static __inline int VOP_LEASE(vp, p, cred, flag)
+       struct vnode *vp;
+       struct proc *p;
+       struct ucred *cred;
+       int flag;
+{
+       struct vop_lease_args a;
+       int rc;
+       a.a_desc = VDESC(vop_lease);
+       a.a_vp = vp;
+       a.a_p = p;
+       a.a_cred = cred;
+       a.a_flag = flag;
+       rc = VCALL(vp, VOFFSET(vop_lease), &a);
+       return (rc);
+}
+struct vop_ioctl_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       u_long a_command;
+       caddr_t a_data;
+       int a_fflag;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_ioctl_desc;
+static __inline int VOP_IOCTL __P((
+       struct vnode *vp,
+       u_long command,
+       caddr_t data,
+       int fflag,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_IOCTL(vp, command, data, fflag, cred, p)
+       struct vnode *vp;
+       u_long command;
+       caddr_t data;
+       int fflag;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_ioctl_args a;
+       int rc;
+       a.a_desc = VDESC(vop_ioctl);
+       a.a_vp = vp;
+       a.a_command = command;
+       a.a_data = data;
+       a.a_fflag = fflag;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_ioctl), &a);
+       return (rc);
+}
+struct vop_poll_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       int a_events;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_poll_desc;
+static __inline int VOP_POLL __P((
+       struct vnode *vp,
+       int events,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_POLL(vp, events, cred, p)
+       struct vnode *vp;
+       int events;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_poll_args a;
+       int rc;
+       a.a_desc = VDESC(vop_poll);
+       a.a_vp = vp;
+       a.a_events = events;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_poll), &a);
+       return (rc);
+}
+struct vop_revoke_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       int a_flags;
+};
+extern struct vnodeop_desc vop_revoke_desc;
+static __inline int VOP_REVOKE __P((
+       struct vnode *vp,
+       int flags));
+static __inline int VOP_REVOKE(vp, flags)
+       struct vnode *vp;
+       int flags;
+{
+       struct vop_revoke_args a;
+       int rc;
+       a.a_desc = VDESC(vop_revoke);
+       a.a_vp = vp;
+       a.a_flags = flags;
+       rc = VCALL(vp, VOFFSET(vop_revoke), &a);
+       return (rc);
+}
+struct vop_mmap_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       int a_fflags;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_mmap_desc;
+static __inline int VOP_MMAP __P((
+       struct vnode *vp,
+       int fflags,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_MMAP(vp, fflags, cred, p)
+       struct vnode *vp;
+       int fflags;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_mmap_args a;
+       int rc;
+       a.a_desc = VDESC(vop_mmap);
+       a.a_vp = vp;
+       a.a_fflags = fflags;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_mmap), &a);
+       return (rc);
+}
+struct vop_fsync_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct ucred *a_cred;
+       int a_waitfor;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_fsync_desc;
+static __inline int VOP_FSYNC __P((
+       struct vnode *vp,
+       struct ucred *cred,
+       int waitfor,
+       struct proc *p));
+static __inline int VOP_FSYNC(vp, cred, waitfor, p)
+       struct vnode *vp;
+       struct ucred *cred;
+       int waitfor;
+       struct proc *p;
+{
+       struct vop_fsync_args a;
+       int rc;
+       a.a_desc = VDESC(vop_fsync);
+       a.a_vp = vp;
+       a.a_cred = cred;
+       a.a_waitfor = waitfor;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_fsync), &a);
+       return (rc);
+}
+struct vop_remove_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_dvp;
+       struct vnode *a_vp;
+       struct componentname *a_cnp;
+};
+extern struct vnodeop_desc vop_remove_desc;
+static __inline int VOP_REMOVE __P((
+       struct vnode *dvp,
+       struct vnode *vp,
+       struct componentname *cnp));
+static __inline int VOP_REMOVE(dvp, vp, cnp)
+       struct vnode *dvp;
+       struct vnode *vp;
+       struct componentname *cnp;
+{
+       struct vop_remove_args a;
+       int rc;
+       a.a_desc = VDESC(vop_remove);
+       a.a_dvp = dvp;
+       a.a_vp = vp;
+       a.a_cnp = cnp;
+       rc = VCALL(dvp, VOFFSET(vop_remove), &a);
+       return (rc);
+}
+struct vop_link_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_tdvp;
+       struct vnode *a_vp;
+       struct componentname *a_cnp;
+};
+extern struct vnodeop_desc vop_link_desc;
+static __inline int VOP_LINK __P((
+       struct vnode *tdvp,
+       struct vnode *vp,
+       struct componentname *cnp));
+static __inline int VOP_LINK(tdvp, vp, cnp)
+       struct vnode *tdvp;
+       struct vnode *vp;
+       struct componentname *cnp;
+{
+       struct vop_link_args a;
+       int rc;
+       a.a_desc = VDESC(vop_link);
+       a.a_tdvp = tdvp;
+       a.a_vp = vp;
+       a.a_cnp = cnp;
+       rc = VCALL(tdvp, VOFFSET(vop_link), &a);
+       return (rc);
+}
+struct vop_rename_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_fdvp;
+       struct vnode *a_fvp;
+       struct componentname *a_fcnp;
+       struct vnode *a_tdvp;
+       struct vnode *a_tvp;
+       struct componentname *a_tcnp;
+};
+extern struct vnodeop_desc vop_rename_desc;
+static __inline int VOP_RENAME __P((
+       struct vnode *fdvp,
+       struct vnode *fvp,
+       struct componentname *fcnp,
+       struct vnode *tdvp,
+       struct vnode *tvp,
+       struct componentname *tcnp));
+static __inline int VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
+       struct vnode *fdvp;
+       struct vnode *fvp;
+       struct componentname *fcnp;
+       struct vnode *tdvp;
+       struct vnode *tvp;
+       struct componentname *tcnp;
+{
+       struct vop_rename_args a;
+       int rc;
+       a.a_desc = VDESC(vop_rename);
+       a.a_fdvp = fdvp;
+       a.a_fvp = fvp;
+       a.a_fcnp = fcnp;
+       a.a_tdvp = tdvp;
+       a.a_tvp = tvp;
+       a.a_tcnp = tcnp;
+       rc = VCALL(fdvp, VOFFSET(vop_rename), &a);
+       return (rc);
+}
+struct vop_mkdir_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_dvp;
+       struct vnode **a_vpp;
+       struct componentname *a_cnp;
+       struct vattr *a_vap;
+};
+extern struct vnodeop_desc vop_mkdir_desc;
+static __inline int VOP_MKDIR __P((
+       struct vnode *dvp,
+       struct vnode **vpp,
+       struct componentname *cnp,
+       struct vattr *vap));
+static __inline int VOP_MKDIR(dvp, vpp, cnp, vap)
+       struct vnode *dvp;
+       struct vnode **vpp;
+       struct componentname *cnp;
+       struct vattr *vap;
+{
+       struct vop_mkdir_args a;
+       int rc;
+       a.a_desc = VDESC(vop_mkdir);
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = cnp;
+       a.a_vap = vap;
+       rc = VCALL(dvp, VOFFSET(vop_mkdir), &a);
+       return (rc);
+}
+struct vop_rmdir_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_dvp;
+       struct vnode *a_vp;
+       struct componentname *a_cnp;
+};
+extern struct vnodeop_desc vop_rmdir_desc;
+static __inline int VOP_RMDIR __P((
+       struct vnode *dvp,
+       struct vnode *vp,
+       struct componentname *cnp));
+static __inline int VOP_RMDIR(dvp, vp, cnp)
+       struct vnode *dvp;
+       struct vnode *vp;
+       struct componentname *cnp;
+{
+       struct vop_rmdir_args a;
+       int rc;
+       a.a_desc = VDESC(vop_rmdir);
+       a.a_dvp = dvp;
+       a.a_vp = vp;
+       a.a_cnp = cnp;
+       rc = VCALL(dvp, VOFFSET(vop_rmdir), &a);
+       return (rc);
+}
+struct vop_symlink_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_dvp;
+       struct vnode **a_vpp;
+       struct componentname *a_cnp;
+       struct vattr *a_vap;
+       char *a_target;
+};
+extern struct vnodeop_desc vop_symlink_desc;
+static __inline int VOP_SYMLINK __P((
+       struct vnode *dvp,
+       struct vnode **vpp,
+       struct componentname *cnp,
+       struct vattr *vap,
+       char *target));
+static __inline int VOP_SYMLINK(dvp, vpp, cnp, vap, target)
+       struct vnode *dvp;
+       struct vnode **vpp;
+       struct componentname *cnp;
+       struct vattr *vap;
+       char *target;
+{
+       struct vop_symlink_args a;
+       int rc;
+       a.a_desc = VDESC(vop_symlink);
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = cnp;
+       a.a_vap = vap;
+       a.a_target = target;
+       rc = VCALL(dvp, VOFFSET(vop_symlink), &a);
+       return (rc);
+}
+struct vop_readdir_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct uio *a_uio;
+       struct ucred *a_cred;
+       int *a_eofflag;
+       int *a_ncookies;
+       u_long **a_cookies;
+};
+extern struct vnodeop_desc vop_readdir_desc;
+static __inline int VOP_READDIR __P((
+       struct vnode *vp,
+       struct uio *uio,
+       struct ucred *cred,
+       int *eofflag,
+       int *ncookies,
+       u_long **cookies));
+static __inline int VOP_READDIR(vp, uio, cred, eofflag, ncookies, cookies)
+       struct vnode *vp;
+       struct uio *uio;
+       struct ucred *cred;
+       int *eofflag;
+       int *ncookies;
+       u_long **cookies;
+{
+       struct vop_readdir_args a;
+       int rc;
+       a.a_desc = VDESC(vop_readdir);
+       a.a_vp = vp;
+       a.a_uio = uio;
+       a.a_cred = cred;
+       a.a_eofflag = eofflag;
+       a.a_ncookies = ncookies;
+       a.a_cookies = cookies;
+       rc = VCALL(vp, VOFFSET(vop_readdir), &a);
+       return (rc);
+}
+struct vop_readlink_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct uio *a_uio;
+       struct ucred *a_cred;
+};
+extern struct vnodeop_desc vop_readlink_desc;
+static __inline int VOP_READLINK __P((
+       struct vnode *vp,
+       struct uio *uio,
+       struct ucred *cred));
+static __inline int VOP_READLINK(vp, uio, cred)
+       struct vnode *vp;
+       struct uio *uio;
+       struct ucred *cred;
+{
+       struct vop_readlink_args a;
+       int rc;
+       a.a_desc = VDESC(vop_readlink);
+       a.a_vp = vp;
+       a.a_uio = uio;
+       a.a_cred = cred;
+       rc = VCALL(vp, VOFFSET(vop_readlink), &a);
+       return (rc);
+}
+struct vop_inactive_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_inactive_desc;
+static __inline int VOP_INACTIVE __P((
+       struct vnode *vp,
+       struct proc *p));
+static __inline int VOP_INACTIVE(vp, p)
+       struct vnode *vp;
+       struct proc *p;
+{
+       struct vop_inactive_args a;
+       int rc;
+       a.a_desc = VDESC(vop_inactive);
+       a.a_vp = vp;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_inactive), &a);
+       return (rc);
+}
+struct vop_reclaim_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_reclaim_desc;
+static __inline int VOP_RECLAIM __P((
+       struct vnode *vp,
+       struct proc *p));
+static __inline int VOP_RECLAIM(vp, p)
+       struct vnode *vp;
+       struct proc *p;
+{
+       struct vop_reclaim_args a;
+       int rc;
+       a.a_desc = VDESC(vop_reclaim);
+       a.a_vp = vp;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_reclaim), &a);
+       return (rc);
+}
+struct vop_lock_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       int a_flags;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_lock_desc;
+static __inline int VOP_LOCK __P((
+       struct vnode *vp,
+       int flags,
+       struct proc *p));
+static __inline int VOP_LOCK(vp, flags, p)
+       struct vnode *vp;
+       int flags;
+       struct proc *p;
+{
+       struct vop_lock_args a;
+       int rc;
+       a.a_desc = VDESC(vop_lock);
+       a.a_vp = vp;
+       a.a_flags = flags;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_lock), &a);
+       return (rc);
+}
+struct vop_unlock_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       int a_flags;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_unlock_desc;
+static __inline int VOP_UNLOCK __P((
+       struct vnode *vp,
+       int flags,
+       struct proc *p));
+static __inline int VOP_UNLOCK(vp, flags, p)
+       struct vnode *vp;
+       int flags;
+       struct proc *p;
+{
+       struct vop_unlock_args a;
+       int rc;
+       a.a_desc = VDESC(vop_unlock);
+       a.a_vp = vp;
+       a.a_flags = flags;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_unlock), &a);
+       return (rc);
+}
+struct vop_bmap_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       daddr_t a_bn;
+       struct vnode **a_vpp;
+       daddr_t *a_bnp;
+       int *a_runp;
+       int *a_runb;
+};
+extern struct vnodeop_desc vop_bmap_desc;
+static __inline int VOP_BMAP __P((
+       struct vnode *vp,
+       daddr_t bn,
+       struct vnode **vpp,
+       daddr_t *bnp,
+       int *runp,
+       int *runb));
+static __inline int VOP_BMAP(vp, bn, vpp, bnp, runp, runb)
+       struct vnode *vp;
+       daddr_t bn;
+       struct vnode **vpp;
+       daddr_t *bnp;
+       int *runp;
+       int *runb;
+{
+       struct vop_bmap_args a;
+       int rc;
+       a.a_desc = VDESC(vop_bmap);
+       a.a_vp = vp;
+       a.a_bn = bn;
+       a.a_vpp = vpp;
+       a.a_bnp = bnp;
+       a.a_runp = runp;
+       a.a_runb = runb;
+       rc = VCALL(vp, VOFFSET(vop_bmap), &a);
+       return (rc);
+}
+struct vop_strategy_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct buf *a_bp;
+};
+extern struct vnodeop_desc vop_strategy_desc;
+static __inline int VOP_STRATEGY __P((
+       struct vnode *vp,
+       struct buf *bp));
+static __inline int VOP_STRATEGY(vp, bp)
+       struct vnode *vp;
+       struct buf *bp;
+{
+       struct vop_strategy_args a;
+       int rc;
+       a.a_desc = VDESC(vop_strategy);
+       a.a_vp = vp;
+       a.a_bp = bp;
+       rc = VCALL(vp, VOFFSET(vop_strategy), &a);
+       return (rc);
+}
+struct vop_print_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+};
+extern struct vnodeop_desc vop_print_desc;
+static __inline int VOP_PRINT __P((
+       struct vnode *vp));
+static __inline int VOP_PRINT(vp)
+       struct vnode *vp;
+{
+       struct vop_print_args a;
+       int rc;
+       a.a_desc = VDESC(vop_print);
+       a.a_vp = vp;
+       rc = VCALL(vp, VOFFSET(vop_print), &a);
+       return (rc);
+}
+struct vop_pathconf_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       int a_name;
+       register_t *a_retval;
+};
+extern struct vnodeop_desc vop_pathconf_desc;
+static __inline int VOP_PATHCONF __P((
+       struct vnode *vp,
+       int name,
+       register_t *retval));
+static __inline int VOP_PATHCONF(vp, name, retval)
+       struct vnode *vp;
+       int name;
+       register_t *retval;
+{
+       struct vop_pathconf_args a;
+       int rc;
+       a.a_desc = VDESC(vop_pathconf);
+       a.a_vp = vp;
+       a.a_name = name;
+       a.a_retval = retval;
+       rc = VCALL(vp, VOFFSET(vop_pathconf), &a);
+       return (rc);
+}
+struct vop_advlock_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       caddr_t a_id;
+       int a_op;
+       struct flock *a_fl;
+       int a_flags;
+};
+extern struct vnodeop_desc vop_advlock_desc;
+static __inline int VOP_ADVLOCK __P((
+       struct vnode *vp,
+       caddr_t id,
+       int op,
+       struct flock *fl,
+       int flags));
+static __inline int VOP_ADVLOCK(vp, id, op, fl, flags)
+       struct vnode *vp;
+       caddr_t id;
+       int op;
+       struct flock *fl;
+       int flags;
+{
+       struct vop_advlock_args a;
+       int rc;
+       a.a_desc = VDESC(vop_advlock);
+       a.a_vp = vp;
+       a.a_id = id;
+       a.a_op = op;
+       a.a_fl = fl;
+       a.a_flags = flags;
+       rc = VCALL(vp, VOFFSET(vop_advlock), &a);
+       return (rc);
+}
+struct vop_balloc_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       off_t a_startoffset;
+       int a_size;
+       struct ucred *a_cred;
+       int a_flags;
+       struct buf **a_bpp;
+};
+extern struct vnodeop_desc vop_balloc_desc;
+static __inline int VOP_BALLOC __P((
+       struct vnode *vp,
+       off_t startoffset,
+       int size,
+       struct ucred *cred,
+       int flags,
+       struct buf **bpp));
+static __inline int VOP_BALLOC(vp, startoffset, size, cred, flags, bpp)
+       struct vnode *vp;
+       off_t startoffset;
+       int size;
+       struct ucred *cred;
+       int flags;
+       struct buf **bpp;
+{
+       struct vop_balloc_args a;
+       int rc;
+       a.a_desc = VDESC(vop_balloc);
+       a.a_vp = vp;
+       a.a_startoffset = startoffset;
+       a.a_size = size;
+       a.a_cred = cred;
+       a.a_flags = flags;
+       a.a_bpp = bpp;
+       rc = VCALL(vp, VOFFSET(vop_balloc), &a);
+       return (rc);
+}
+struct vop_reallocblks_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct cluster_save *a_buflist;
+};
+extern struct vnodeop_desc vop_reallocblks_desc;
+static __inline int VOP_REALLOCBLKS __P((
+       struct vnode *vp,
+       struct cluster_save *buflist));
+static __inline int VOP_REALLOCBLKS(vp, buflist)
+       struct vnode *vp;
+       struct cluster_save *buflist;
+{
+       struct vop_reallocblks_args a;
+       int rc;
+       a.a_desc = VDESC(vop_reallocblks);
+       a.a_vp = vp;
+       a.a_buflist = buflist;
+       rc = VCALL(vp, VOFFSET(vop_reallocblks), &a);
+       return (rc);
+}
+struct vop_getpages_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       vm_page_t *a_m;
+       int a_count;
+       int a_reqpage;
+       vm_ooffset_t a_offset;
+};
+extern struct vnodeop_desc vop_getpages_desc;
+static __inline int VOP_GETPAGES __P((
+       struct vnode *vp,
+       vm_page_t *m,
+       int count,
+       int reqpage,
+       vm_ooffset_t offset));
+static __inline int VOP_GETPAGES(vp, m, count, reqpage, offset)
+       struct vnode *vp;
+       vm_page_t *m;
+       int count;
+       int reqpage;
+       vm_ooffset_t offset;
+{
+       struct vop_getpages_args a;
+       int rc;
+       a.a_desc = VDESC(vop_getpages);
+       a.a_vp = vp;
+       a.a_m = m;
+       a.a_count = count;
+       a.a_reqpage = reqpage;
+       a.a_offset = offset;
+       rc = VCALL(vp, VOFFSET(vop_getpages), &a);
+       return (rc);
+}
+struct vop_putpages_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       vm_page_t *a_m;
+       int a_count;
+       int a_sync;
+       int *a_rtvals;
+       vm_ooffset_t a_offset;
+};
+extern struct vnodeop_desc vop_putpages_desc;
+static __inline int VOP_PUTPAGES __P((
+       struct vnode *vp,
+       vm_page_t *m,
+       int count,
+       int sync,
+       int *rtvals,
+       vm_ooffset_t offset));
+static __inline int VOP_PUTPAGES(vp, m, count, sync, rtvals, offset)
+       struct vnode *vp;
+       vm_page_t *m;
+       int count;
+       int sync;
+       int *rtvals;
+       vm_ooffset_t offset;
+{
+       struct vop_putpages_args a;
+       int rc;
+       a.a_desc = VDESC(vop_putpages);
+       a.a_vp = vp;
+       a.a_m = m;
+       a.a_count = count;
+       a.a_sync = sync;
+       a.a_rtvals = rtvals;
+       a.a_offset = offset;
+       rc = VCALL(vp, VOFFSET(vop_putpages), &a);
+       return (rc);
+}
+struct vop_freeblks_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       daddr_t a_addr;
+       daddr_t a_length;
+};
+extern struct vnodeop_desc vop_freeblks_desc;
+static __inline int VOP_FREEBLKS __P((
+       struct vnode *vp,
+       daddr_t addr,
+       daddr_t length));
+static __inline int VOP_FREEBLKS(vp, addr, length)
+       struct vnode *vp;
+       daddr_t addr;
+       daddr_t length;
+{
+       struct vop_freeblks_args a;
+       int rc;
+       a.a_desc = VDESC(vop_freeblks);
+       a.a_vp = vp;
+       a.a_addr = addr;
+       a.a_length = length;
+       rc = VCALL(vp, VOFFSET(vop_freeblks), &a);
+       return (rc);
+}
+struct vop_bwrite_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       struct buf *a_bp;
+};
+extern struct vnodeop_desc vop_bwrite_desc;
+static __inline int VOP_BWRITE __P((
+       struct vnode *vp,
+       struct buf *bp));
+static __inline int VOP_BWRITE(vp, bp)
+       struct vnode *vp;
+       struct buf *bp;
+{
+       struct vop_bwrite_args a;
+       int rc;
+       a.a_desc = VDESC(vop_bwrite);
+       a.a_vp = vp;
+       a.a_bp = bp;
+       rc = VCALL(vp, VOFFSET(vop_bwrite), &a);
+       return (rc);
+}
+struct vop_getacl_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       acl_type_t a_type;
+       struct acl *a_aclp;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_getacl_desc;
+static __inline int VOP_GETACL __P((
+       struct vnode *vp,
+       acl_type_t type,
+       struct acl *aclp,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_GETACL(vp, type, aclp, cred, p)
+       struct vnode *vp;
+       acl_type_t type;
+       struct acl *aclp;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_getacl_args a;
+       int rc;
+       a.a_desc = VDESC(vop_getacl);
+       a.a_vp = vp;
+       a.a_type = type;
+       a.a_aclp = aclp;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_getacl), &a);
+       return (rc);
+}
+struct vop_setacl_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       acl_type_t a_type;
+       struct acl *a_aclp;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_setacl_desc;
+static __inline int VOP_SETACL __P((
+       struct vnode *vp,
+       acl_type_t type,
+       struct acl *aclp,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_SETACL(vp, type, aclp, cred, p)
+       struct vnode *vp;
+       acl_type_t type;
+       struct acl *aclp;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_setacl_args a;
+       int rc;
+       a.a_desc = VDESC(vop_setacl);
+       a.a_vp = vp;
+       a.a_type = type;
+       a.a_aclp = aclp;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_setacl), &a);
+       return (rc);
+}
+struct vop_aclcheck_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       acl_type_t a_type;
+       struct acl *a_aclp;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_aclcheck_desc;
+static __inline int VOP_ACLCHECK __P((
+       struct vnode *vp,
+       acl_type_t type,
+       struct acl *aclp,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_ACLCHECK(vp, type, aclp, cred, p)
+       struct vnode *vp;
+       acl_type_t type;
+       struct acl *aclp;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_aclcheck_args a;
+       int rc;
+       a.a_desc = VDESC(vop_aclcheck);
+       a.a_vp = vp;
+       a.a_type = type;
+       a.a_aclp = aclp;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_aclcheck), &a);
+       return (rc);
+}
+struct vop_getextattr_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       char *a_name;
+       struct uio *a_uio;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_getextattr_desc;
+static __inline int VOP_GETEXTATTR __P((
+       struct vnode *vp,
+       char *name,
+       struct uio *uio,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_GETEXTATTR(vp, name, uio, cred, p)
+       struct vnode *vp;
+       char *name;
+       struct uio *uio;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_getextattr_args a;
+       int rc;
+       a.a_desc = VDESC(vop_getextattr);
+       a.a_vp = vp;
+       a.a_name = name;
+       a.a_uio = uio;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_getextattr), &a);
+       return (rc);
+}
+struct vop_setextattr_args {
+       struct vnodeop_desc *a_desc;
+       struct vnode *a_vp;
+       char *a_name;
+       struct uio *a_uio;
+       struct ucred *a_cred;
+       struct proc *a_p;
+};
+extern struct vnodeop_desc vop_setextattr_desc;
+static __inline int VOP_SETEXTATTR __P((
+       struct vnode *vp,
+       char *name,
+       struct uio *uio,
+       struct ucred *cred,
+       struct proc *p));
+static __inline int VOP_SETEXTATTR(vp, name, uio, cred, p)
+       struct vnode *vp;
+       char *name;
+       struct uio *uio;
+       struct ucred *cred;
+       struct proc *p;
+{
+       struct vop_setextattr_args a;
+       int rc;
+       a.a_desc = VDESC(vop_setextattr);
+       a.a_vp = vp;
+       a.a_name = name;
+       a.a_uio = uio;
+       a.a_cred = cred;
+       a.a_p = p;
+       rc = VCALL(vp, VOFFSET(vop_setextattr), &a);
+       return (rc);
+}
index 6a8eb91..efc6126 100644 (file)
@@ -33,7 +33,7 @@ kinstall: AFS_component_version_number.c
                        gencat -m afszcm.cat afs_trace.msf ;; \
                *_linux* ) \
                        gencat --new afszcm.cat afs_trace.msf ;; \
-               ppc_darwin*) \
+               ppc_darwin* | i386_fbsd*) \
                        echo No gencat for ${SYS_NAME} ;; \
                * ) \
                        gencat afszcm.cat afs_trace.msf ;; \
@@ -59,7 +59,7 @@ install install.noversion: kinstall ukinstall
                        ${INSTALL} longc_procs.h ${DESTDIR}include/afs ;; \
        esac
        case ${SYS_NAME} in \
-               next_mach30 | vax_ul43 | ppc_darwin* ) \
+               next_mach30 | vax_ul43 | ppc_darwin* | i386_fbsd* ) \
                        echo skipping afszcm.cat install for ${SYS_NAME} ;; \
                * ) \
                        ${INSTALL} afszcm.cat ${DESTDIR}root.client/usr/vice/etc/C ;; \
index da388ca..2d93e7c 100644 (file)
@@ -1845,7 +1845,7 @@ void uafs_Init(
        iob.out = tbuffer;
        iob.out_size = sizeof(tbuffer);
 
-#if defined(AFS_USR_SUN5_ENV) || defined(AFS_USR_OSF_ENV) || defined(AFS_USR_HPUX_ENV) || defined(AFS_USR_LINUX22_ENV) || defined(AFS_USR_DARWIN_ENV)
+#if defined(AFS_USR_SUN5_ENV) || defined(AFS_USR_OSF_ENV) || defined(AFS_USR_HPUX_ENV) || defined(AFS_USR_LINUX22_ENV) || defined(AFS_USR_DARWIN_ENV) || defined(AFS_USR_FBSD_ENV)
        rc = syscall(AFS_SYSCALL, AFSCALL_PIOCTL, 0, _VICEIOCTL(8), &iob, 0);
 #elif defined(AFS_USR_SGI_ENV)
        rc = syscall(AFS_PIOCTL, 0, _VICEIOCTL(8), &iob, 0);
index 9c768a0..367b6e2 100644 (file)
@@ -11,7 +11,7 @@
 #define __AFS_SYSINCLUDESH__ 1
 
 #include  <stdio.h>
-#ifndef AFS_USR_DARWIN_ENV /* must be included after KERNEL undef'd */
+#if !defined(AFS_USR_DARWIN_ENV) && !defined(AFS_USR_FBSD_ENV) /* must be included after KERNEL undef'd */
 #include  <errno.h>
 #endif
 #include  <stdlib.h>
 #define FREAD                  0x0001
 #endif /* AFS_USR_LINUX22_ENV */
 
-#ifdef AFS_USR_DARWIN_ENV
+#if defined(AFS_USR_DARWIN_ENV) || defined(AFS_USR_FBSD_ENV)
 #ifdef KERNEL
 #undef KERNEL
 #define AFS_USR_UNDEF_KERNEL_ENV 1
 #ifndef O_SYNC
 #define O_SYNC O_FSYNC
 #endif
-#endif /* AFS_USR_DARWIN_ENV */
+#endif /* AFS_USR_DARWIN_ENV || AFS_USR_FBSD_ENV */
 
 /* glibc 2.2 has pthread_attr_setstacksize */
 #if defined(AFS_LINUX22_ENV) || defined(AFS_USR_LINUX22_ENV) && (__GLIBC_MINOR__ < 2)
 #undef socket
 #endif /* AFS_USR_SGI_ENV */
 
-#ifdef AFS_USR_DARWIN_ENV
+#if defined(AFS_USR_DARWIN_ENV) || defined(AFS_USR_FBSD_ENV)
 #undef if_mtu
 #undef if_metric
 #endif
@@ -1326,7 +1326,9 @@ struct min_direct {
 struct usr_ucred {
        unsigned long           cr_ref;
        long                    cr_uid;
+#if !defined(AFS_USR_FBSD_ENV)
        long                    cr_gid;
+#endif
        long                    cr_ruid;
        long                    cr_rgid;
        long                    cr_suid;
index 87e0913..311f216 100644 (file)
@@ -97,11 +97,11 @@ afs_CopyOutAttrs(avc, attrs)
      * anyway, so the difference between 512K and 1000000 shouldn't matter
      * much, and "&" is a lot faster than "%".
      */
-#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     attrs->va_atime.tv_nsec = attrs->va_mtime.tv_nsec =
        attrs->va_ctime.tv_nsec =
            (hgetlo(avc->m.DataVersion) & 0x7ffff) * 1000;
-#if defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     attrs->va_blocksize = PAGESIZE;            /* XXX Was 8192 XXX */
 #else
     attrs->va_blksize = PAGESIZE;              /* XXX Was 8192 XXX */
@@ -137,7 +137,7 @@ afs_CopyOutAttrs(avc, attrs)
     attrs->va_flags = 0;
 #endif /* AFS_OSF_ENV */
 
-#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #if !defined(AFS_HPUX_ENV)
 #ifdef AFS_SUN5_ENV
     attrs->va_nblocks = (attrs->va_size? ((attrs->va_size + 1023)>>10) << 1 : 0);
@@ -151,7 +151,7 @@ afs_CopyOutAttrs(avc, attrs)
 #else /* !defined(AFS_HPUX_ENV) */
     attrs->va_blocks = (attrs->va_size? ((attrs->va_size + 1023)>>10) : 0);
 #endif /* !defined(AFS_HPUX_ENV) */
-#else  /* ! AFS_OSF_ENV */
+#else  /* ! AFS_OSF_ENV && !AFS_FBSD_ENV */
     attrs->va_bytes = (attrs->va_size? (attrs->va_size + 1023) : 1024);
 #ifdef va_bytes_rsv
     attrs->va_bytes_rsv = -1;
@@ -232,7 +232,7 @@ afs_getattr(OSI_VC_ARG(avc), attrs, acred)
                  return EACCES;
              }
              if (avc->mvstat == 2) {
-#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
                  attrs->va_mtime.tv_nsec += ((++avc->xlatordv) * 1000); 
 #else
                  attrs->va_mtime.tv_usec += ++avc->xlatordv; 
@@ -359,7 +359,7 @@ register struct AFSStoreStatus *as; {
 #endif
        mask |= AFS_SETMODTIME;
 #ifndef        AFS_SGI_ENV
-#if    defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV)
+#if    defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
        if (av->va_mtime.tv_nsec == -1)
 #else
        if (av->va_mtime.tv_usec == -1)
index 9bebe95..35375b5 100644 (file)
@@ -40,7 +40,7 @@ void lockIdSet(flock, slp, clid)
 #if    defined(AFS_SUN5_ENV)
     register proc_t *procp = ttoproc(curthread);    
 #else
-#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #ifdef AFS_SGI_ENV
     struct proc *procp = OSI_GET_CURRENT_PROCP();
 #else
@@ -80,7 +80,7 @@ void lockIdSet(flock, slp, clid)
 #endif
         slp->pid = clid;
 #else
-#if    defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if    defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
        slp->pid = clid;
 #else
 #if defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV)
@@ -119,7 +119,7 @@ void lockIdSet(flock, slp, clid)
 #endif
         flock->l_pid = clid;
 #else
-#if    defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if    defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
        flock->l_pid = clid;
 #else
 #if defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV)
@@ -154,7 +154,7 @@ static int lockIdcmp2(flock1, vp, alp, onlymine, clid)
 #if    defined(AFS_SUN5_ENV)
     register proc_t *procp = ttoproc(curthread);    
 #else
-#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #ifdef AFS_SGI64_ENV
     struct proc *procp = curprocp;
 #else /* AFS_SGI64_ENV */
@@ -171,7 +171,7 @@ static int lockIdcmp2(flock1, vp, alp, onlymine, clid)
       }
 #endif
       if ((flock1->l_pid == alp->pid) || 
-#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
          (!onlymine && (flock1->l_pid == getppid()))
 #else
 #if defined(AFS_SGI65_ENV)
@@ -481,7 +481,7 @@ int flag;
 pid_t clid;
 off_t offset;
 #else
-#if defined(AFS_SGI_ENV) || (defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SGI_ENV) || (defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 afs_lockctl(avc, af, acmd, acred, clid)
 pid_t clid;
 #else
@@ -828,7 +828,7 @@ static int GetFlockCount(struct vcache *avc, struct vrequest *areq)
 #endif
 
 
-#if    !defined(AFS_AIX_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_SGI_ENV) && !defined(UKERNEL) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if    !defined(AFS_AIX_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_SGI_ENV) && !defined(UKERNEL) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 /* Flock not support on System V systems */
 #ifdef AFS_OSF_ENV
 extern struct fileops afs_fileops;
@@ -856,7 +856,11 @@ afs_xflock () {
     uap = (struct a *)args;
     getf(&fd, uap->fd, FILE_FLAGS_NULL, &u.u_file_state);
 #else /* AFS_OSF_ENV */
+#if defined(AFS_FBSD_ENV)
     uap = (struct a *)u.u_ap;
+#else
+    uap = (struct a *)u.u_ap;
+#endif /* AFS_FBSD_ENV */
     fd = getf(uap->fd);
 #endif
     if (!fd) return;
index 48a07ea..aa62ffd 100644 (file)
@@ -25,7 +25,7 @@
 
 
 
-#if    defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if    defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 afs_ustrategy(abp, credp)
     struct AFS_UCRED *credp;
 #else
@@ -36,14 +36,14 @@ afs_ustrategy(abp)
     struct uio tuio;
     register struct vcache *tvc = (struct vcache *) abp->b_vp;
     register afs_int32 len = abp->b_bcount;
-#if    !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV)
+#if    !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #ifdef AFS_AIX41_ENV
     struct ucred *credp;
 #else
     struct AFS_UCRED *credp = u.u_cred;
 #endif
 #endif
-#if    defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV)
+#if    defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     int async = abp->b_flags & B_ASYNC;
 #endif
     struct iovec tiovec[1];
@@ -71,7 +71,7 @@ afs_ustrategy(abp)
        */
        tuio.afsio_iov = tiovec;
        tuio.afsio_iovcnt = 1;
-#if    defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) || defined(AFS_SUN5_ENV)
+#if    defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_FBSD_ENV)
        tuio.afsio_offset = (u_int) dbtob(abp->b_blkno);
 #if    defined(AFS_SUN5_ENV)
        tuio._uio_offset._p._u = 0;
@@ -84,7 +84,11 @@ afs_ustrategy(abp)
        tuio.afsio_fmode = 0;
 #endif
        tuio.afsio_resid = abp->b_bcount;
+#if defined(AFS_FBSD_ENV)
+       tiovec[0].iov_base = abp->b_saveaddr;
+#else
        tiovec[0].iov_base = abp->b_un.b_addr;
+#endif /* AFS_FBSD_ENV */
        tiovec[0].iov_len = abp->b_bcount;
        /* are user's credentials valid here?  probably, but this
             sure seems like the wrong things to do. */
@@ -95,7 +99,11 @@ afs_ustrategy(abp)
 #endif
        if (code == 0) {
            if (tuio.afsio_resid > 0)
+#if defined(AFS_FBSD_ENV)
+               bzero(abp->b_saveaddr + abp->b_bcount - tuio.afsio_resid, tuio.afsio_resid);
+#else
                bzero(abp->b_un.b_addr + abp->b_bcount - tuio.afsio_resid, tuio.afsio_resid);
+#endif /* AFS_FBSD_ENV */
 #ifdef AFS_AIX32_ENV
            /*
             * If we read a block that is past EOF and the user was not storing
@@ -140,7 +148,11 @@ afs_ustrategy(abp)
        len = MIN(abp->b_bcount, ((struct vcache *)abp->b_vp)->m.Length - dbtob(abp->b_blkno));
 #endif /* AFS_ALPHA_ENV */
        tuio.afsio_resid = len;
+#if defined(AFS_FBSD_ENV)
+       tiovec[0].iov_base = abp->b_saveaddr;
+#else
        tiovec[0].iov_base = abp->b_un.b_addr;
+#endif /* AFS_FBSD_ENV */
        tiovec[0].iov_len = len;
        /* are user's credentials valid here?  probably, but this
             sure seems like the wrong things to do. */
index 49a3d91..77b56aa 100644 (file)
@@ -529,7 +529,7 @@ afs_UFSWrite(avc, auio, aio, acred, noLock)
        code = osi_file_uio_rdwr(tfile, &tuio, UIO_WRITE);
        AFS_GLOCK();
 #else
-#if defined(AFS_DARWIN_ENV) 
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
         AFS_GUNLOCK();
         VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
         code = VOP_WRITE(tfile->vnode, &tuio, 0, &afs_osi_cred);
@@ -537,7 +537,7 @@ afs_UFSWrite(avc, auio, aio, acred, noLock)
         AFS_GLOCK();
 #else
        code = VOP_RDWR(tfile->vnode, &tuio, UIO_WRITE, 0, &afs_osi_cred);
-#endif /* AFS_DARWIN_ENV */
+#endif /* AFS_DARWIN_ENV || AFS_FBSD_ENV */
 #endif /* AFS_LINUX20_ENV */
 #endif /* AFS_HPUX100_ENV */
 #endif /* AFS_OSF_ENV */
@@ -609,7 +609,7 @@ afs_UFSWrite(avc, auio, aio, acred, noLock)
      * If write is implemented via VM, afs_fsync() is called from the high-level
      * write op.
      */
-#ifdef  AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
      if (noLock && (aio & IO_SYNC)) {
 #else 
 #ifdef AFS_HPUX_ENV
@@ -650,7 +650,7 @@ struct vrequest *areq; {
 
 
 
-#if !defined (AFS_AIX_ENV) && !defined (AFS_HPUX_ENV) && !defined (AFS_SUN5_ENV) && !defined(AFS_SGI_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined (AFS_AIX_ENV) && !defined (AFS_HPUX_ENV) && !defined (AFS_SUN5_ENV) && !defined(AFS_SGI_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #ifdef AFS_DUX50_ENV
 #define vno_close(X) vn_close((X), 0, NOCRED)
 #elif defined(AFS_DUX40_ENV)
index 352c1cf..4f80931 100644 (file)
@@ -509,7 +509,11 @@ struct SimpleLocks {
 #define VPageCleaning 0x2      /* Solaris - Cache Trunc Daemon sez keep out */
 
 #define        CPSIZE      2
+#if !defined(AFS_FBSD_ENV)
 #define        vrefCount   v.v_count
+#else
+#define vrefCount   v.v_usecount
+#endif /* AFS_FBSD_ENV */
 
 #define        AFS_MAXDV   0x7fffffff      /* largest dataversion number */
 #define        AFS_NOTRUNC 0x7fffffff      /* largest dataversion number */
index 32bfc5c..849eb03 100644 (file)
@@ -15,7 +15,7 @@
 #include "../afs/sysincludes.h"        /* Standard vendor system headers */
 
 #ifndef UKERNEL
-#ifndef AFS_LINUX20_ENV
+#if !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV)
 #include <net/if.h>
 #include <netinet/in.h>
 #endif
@@ -23,7 +23,7 @@
 #ifdef AFS_SGI62_ENV
 #include "../h/hashing.h"
 #endif
-#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV)
+#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV)
 #include <netinet/in_var.h>
 #endif
 #endif /* !UKERNEL */
index ec90841..930b294 100644 (file)
@@ -42,7 +42,7 @@ char afs_rootVolumeName[64]="";
 struct afs_icl_set *afs_iclSetp = (struct afs_icl_set*)0;
 struct afs_icl_set *afs_iclLongTermSetp = (struct afs_icl_set*)0;
 
-#if    defined(AFS_GLOBAL_SUNLOCK) && !defined(AFS_HPUX_ENV) && !defined(AFS_AIX41_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV)
+#if    defined(AFS_GLOBAL_SUNLOCK) && !defined(AFS_HPUX_ENV) && !defined(AFS_AIX41_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 
 kmutex_t afs_global_lock;
 kmutex_t afs_rxglobal_lock;
@@ -57,7 +57,7 @@ simple_lock_data_t afs_global_lock;
 #elif defined(AFS_DARWIN_ENV)
 struct lock__bsd__ afs_global_lock;
 #endif
-#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 thread_t afs_global_owner;
 #endif /* AFS_OSF_ENV */
 
index 478d3d8..9c7018f 100644 (file)
@@ -1237,7 +1237,7 @@ static int afs_UFSCacheStoreProc(acall, afile, alen, avc, shouldWake,
        tlen = (alen > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : alen);
        got = afs_osi_Read(afile, -1, tbuffer, tlen);
        if ((got < 0) 
-#if    !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if    !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
            || (got != tlen && getuerror())
 #endif
            ) {
@@ -2300,7 +2300,7 @@ struct dcache *afs_UFSGetDSlot(aslot, tmpdc)
        tdc->f.chunk = -1;
        hones(tdc->f.versionNo);
        tdc->flags |= DFEntryMod;
-#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
        last_error = getuerror();
 #endif
        lasterrtime = osi_Time();
index 00f38a5..9cfb261 100644 (file)
@@ -432,11 +432,11 @@ afs_InitCacheInfo(afile)
              TO_KERNEL_SPACE();
          }
 #else
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
         if (!VFS_STATFS(filevp->v_mount, &st, current_proc()))
 #else 
        if (!VFS_STATFS(filevp->v_vfsp, &st))  
-#endif /* AFS_DARWIN_ENV */
+#endif /* AFS_DARWIN_ENV || AFS_FBSD_ENV */
 #endif /* AFS_LINUX20_ENV */
 #endif /* AIX41 */
 #endif /* OSF */
index e987925..e36f9b8 100644 (file)
@@ -50,7 +50,7 @@ void osi_Init()
 #elif defined(AFS_OSF_ENV)
     usimple_lock_init(&afs_global_lock);
     afs_global_owner = (thread_t)0;
-#elif defined(AFS_DARWIN_ENV)
+#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     lockinit(&afs_global_lock, PLOCK, "afs global lock", 0, 0);
     afs_global_owner = (thread_t)0;
 #elif defined(AFS_AIX41_ENV)
@@ -80,7 +80,7 @@ void osi_Init()
 osi_Active(avc)
 register struct vcache *avc; {
     AFS_STATCNT(osi_Active);
-#if defined(AFS_SUN_ENV) || defined(AFS_AIX_ENV) || defined(AFS_OSF_ENV) || defined(AFS_SUN5_ENV) || (AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SUN_ENV) || defined(AFS_AIX_ENV) || defined(AFS_OSF_ENV) || defined(AFS_SUN5_ENV) || (AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     if ((avc->opens > 0) || (avc->states & CMAPPED))   return 1;   /* XXX: Warning, verify this XXX  */
 #else
 #if    defined(AFS_MACH_ENV)
@@ -295,7 +295,7 @@ void afs_osi_Invisible() {
 #if    defined(AFS_HPUX101_ENV)
     set_system_proc(u.u_procp);
 #else
-#if defined(AFS_DARWIN_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     current_proc()->p_flag |= P_SYSTEM;
 #else
 #if !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV)
@@ -351,7 +351,7 @@ afs_osi_SetTime(atv)
     stime(&sta);
     AFS_GLOCK();
 #else
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     AFS_GUNLOCK();
     setthetime(atv);
     AFS_GLOCK();
@@ -379,7 +379,7 @@ afs_osi_SetTime(atv)
 #ifdef AFS_AUX_ENV
     logtchg(atv->tv_sec);
 #endif
-#endif  /* AFS_DARWIN_ENV */
+#endif  /* AFS_DARWIN_ENV || AFS_FBSD_ENV */
 #endif /* AFS_SGI_ENV */
 #endif /* AFS_SUN55_ENV */
 #endif /* AFS_SUN5_ENV */
@@ -742,7 +742,7 @@ extern int npid;
 }
 #endif
 
-#if defined(AFS_DARWIN_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 void afs_osi_TraverseProcTable()
 {   
     struct proc *p;
@@ -914,7 +914,7 @@ const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pr)
 
     return rv;
 }
-#elif defined(AFS_DARWIN_ENV)
+#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pr)
 {   
     struct AFS_UCRED *rv=NULL;
index bae946e..54063e6 100644 (file)
@@ -109,7 +109,7 @@ extern void  osi_FreeLargeSpace(void *x);
 /*
  * Vnode related macros
  */
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 extern int (**afs_vnodeop_p)();
 #define IsAfsVnode(vc)      ((vc)->v_op == afs_vnodeop_p)
 #define SetAfsVnode(vc)     (vc)->v_op = afs_vnodeop_p
@@ -236,7 +236,7 @@ typedef struct timeval osi_timeval_t;
  * (Also, of course, the vnode is assumed to be one of ours.  Can't use this
  * macro for V-file vnodes.)
  */
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 /* Bare refcount manipulation would probably work on this platform, but just
    calling VREF does not */
 #define AFS_FAST_HOLD(vp) osi_vnhold((vp),0)
@@ -282,7 +282,7 @@ typedef struct timeval osi_timeval_t;
                AFS_GLOCK();                                    \
        } while(0)
 
-#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                       \
        do {                                                    \
            int haveGlock = ISAFS_GLOCK();                      \
@@ -293,7 +293,7 @@ typedef struct timeval osi_timeval_t;
            if (haveGlock)                                      \
                AFS_GLOCK();                                    \
        } while(0)
-#else /* AFS_OSF_ENV */
+#else /* AFS_OSF_ENV || AFS_FBSD_ENV */
 #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                       \
        do {                                                    \
            int haveGlock = ISAFS_GLOCK();                      \
@@ -303,7 +303,7 @@ typedef struct timeval osi_timeval_t;
            if (haveGlock)                                      \
                AFS_GLOCK();                                    \
        } while(0)
-#endif /* AFS_OSF_ENV */
+#endif /* AFS_OSF_ENV || AFS_FBSD_ENV */
 
 #else /* AFS_GLOBAL_SUNLOCK */
 
@@ -322,18 +322,18 @@ typedef struct timeval osi_timeval_t;
            CODE = copyout((SRC),(DST),(LEN));                  \
        } while(0)
 
-#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                       \
        do {                                                    \
            (UIO)->uio_rw = (RW);                               \
            CODE = uiomove((SRC),(LEN),(UIO));                  \
        } while(0)
-#else /* AFS_OSF_ENV */
+#else /* AFS_OSF_ENV || AFS_FBSD_ENV */
 #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                       \
        do {                                                    \
            CODE = uiomove((SRC),(LEN),(RW),(UIO));             \
        } while(0)
-#endif /* AFS_OSF_ENV */
+#endif /* AFS_OSF_ENV || AFS_FBSD_ENV */
 
 #endif /* AFS_GLOBAL_SUNLOCK */
 
index 354adcc..a1b6cec 100644 (file)
@@ -100,7 +100,7 @@ afs_uint32 getpag(void) {
 int
 #if    defined(AFS_SUN5_ENV)
 afs_setpag (struct AFS_UCRED **credpp)
-#elif  defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#elif  defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 afs_setpag (struct proc *p, void *args, int *retval)
 #else
 afs_setpag (void) 
@@ -127,7 +127,7 @@ afs_setpag (void)
 
 #if    defined(AFS_SUN5_ENV)
     code = AddPag(genpag(), credpp);
-#elif  defined(AFS_OSF_ENV)
+#elif  defined(AFS_OSF_ENV) || defined(AFS_FBSD_ENV)
     code = AddPag(p, genpag(), &p->p_rcred);
 #elif  defined(AFS_AIX41_ENV)
     {
@@ -159,7 +159,7 @@ afs_setpag (void)
        code = AddPag(genpag(), &credp);
        crfree(credp);
     }
-#elif defined(AFS_DARWIN_ENV) 
+#elif defined(AFS_DARWIN_ENV)  || defined(AFS_FBSD_ENV)
     {
        struct ucred *credp=crdup(p->p_cred->pc_ucred);
        code=AddPag(p, genpag(), &credp);
@@ -170,7 +170,7 @@ afs_setpag (void)
 #endif
 
     afs_Trace1(afs_iclSetp, CM_TRACE_SETPAG, ICL_TYPE_INT32, code);
-#if    defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if    defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #if defined(AFS_SGI53_ENV) && defined(MP)
     AFS_GUNLOCK();
 #endif /* defined(AFS_SGI53_ENV) && defined(MP) */    
@@ -182,20 +182,20 @@ afs_setpag (void)
 #endif
 }
 
-#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 int AddPag(struct proc *p, afs_int32 aval, struct AFS_UCRED **credpp)
-#else  /* AFS_OSF_ENV */
+#else  /* AFS_OSF_ENV || AFS_FBSD_ENV */
 int AddPag(afs_int32 aval, struct AFS_UCRED **credpp)
 #endif
 {
     afs_int32 newpag, code;
     AFS_STATCNT(AddPag);
-#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     if (code = setpag(p, credpp, aval, &newpag, 0))
 #else  /* AFS_OSF_ENV */
     if (code = setpag(credpp, aval, &newpag, 0))
 #endif
-#if    defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if    defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
        return (code);
 #else
        return (setuerror(code), code);
@@ -217,7 +217,7 @@ afs_InitReq(av, acred)
         * think it's ok to use the real uid to make setuid
          * programs (without setpag) to work properly.
          */
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
         av->uid = acred->cr_uid;    /* default when no pag is set */
                                     /* bsd creds don't have ruid */
 #else
@@ -279,7 +279,7 @@ afs_int32 PagInCred(const struct AFS_UCRED *cred)
     if (cred == NULL) {
        return NOPAG;
     }
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     if (cred == NOCRED || cred == FSCRED) {
         return NOPAG;
     }
@@ -293,7 +293,7 @@ afs_int32 PagInCred(const struct AFS_UCRED *cred)
        return NOPAG;
     }
 #else
-#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DUX40_ENV) || defined(AFS_LINUX_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DUX40_ENV) || defined(AFS_LINUX_ENV) || defined(AFS_FBSD_ENV)
     if (cred->cr_ngroups < 2) return NOPAG;
 #endif
 #endif
index 109487f..bd100ab 100644 (file)
@@ -38,9 +38,9 @@ extern void afs_osi_TraverseProcTable(void);
 /* afs_osi_pag.c */
 extern afs_uint32 genpag(void);
 extern afs_uint32 getpag(void);
-#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 extern int AddPag(struct proc *p, afs_int32 aval, struct AFS_UCRED **credpp);
-#else  /* AFS_OSF_ENV */
+#else  /* AFS_OSF_ENV || AFS_FBSD_ENV */
 extern int AddPag(afs_int32 aval, struct AFS_UCRED **credpp);
 #endif
 extern afs_uint32 afs_get_pag_from_groups(gid_t g0, gid_t g1);
@@ -119,7 +119,7 @@ extern void InstallUVolumeEntry(struct volume *av, struct uvldbentry *ve,
                         int acell, struct cell *tcell, struct vrequest *areq);
 extern void afs_ResetVolumeInfo(struct volume *tv);
 
-#if defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_AIX_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_AIX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include "../afs/osi_prototypes.h"
 #endif
 
index 62bbfc7..e8dfc7f 100644 (file)
@@ -1202,7 +1202,7 @@ static afs_SetServerPrefs(sa)
 #ifdef AFS_SGI62_ENV
     (void) hash_enum(&hashinfo_inaddr, afsi_enum_set_rank, HTF_INET, NULL,
                     (caddr_t)sa, NULL);
-#elif defined(AFS_DARWIN_ENV)
+#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     {
         struct in_ifaddr *ifa;
         TAILQ_FOREACH(ifa , &in_ifaddrhead, ia_link) {
index b1f61fd..3c2a5d5 100644 (file)
@@ -606,7 +606,7 @@ void afs_GCPAGs_perproc_func(AFS_PROC *pproc)
     afs_GCPAGs_cred_count++;
 
     pag = PagInCred(pcred);
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD40_ENV)
     uid = (pag != NOPAG ? pag : pcred->cr_uid);
 #else
     uid = (pag != NOPAG ? pag : pcred->cr_ruid);
index 0fb0d85..834b45f 100644 (file)
@@ -51,6 +51,6 @@
 #include "../afs/afs_axscache.h"
 #include "../afs/icl.h"
 #include "../afs/afs_prototypes.h"
-#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include "../afs/osi_machdep.h"
 #endif
index 30487e9..fa3745c 100644 (file)
@@ -39,7 +39,7 @@
 #define        AFS_XLATOR_MAGIC        0x87654321
 #endif
 
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #define AFS_NFSXLATORREQ(cred) 0
 #else
 #ifdef AFS_OSF_ENV
index 866b806..4318a66 100644 (file)
@@ -109,7 +109,7 @@ extern tid_t thread_self();
 #ifdef AFS_LINUX20_ENV
 #define MyPidxx current->pid
 #else
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #define MyPidxx (current_proc()->p_pid )
 #else
 #define MyPidxx (u.u_procp->p_pid )
index 2899851..0475ced 100644 (file)
@@ -41,7 +41,7 @@ struct xfs_inode_info {};
 #include <linux/errno.h>
 
 #else /* AFS_LINUX22_ENV */
-#ifdef AFS_DARWIN_ENV    
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #define _MACH_ETAP_H_   
 typedef unsigned short                  etap_event_t; 
 #endif
@@ -132,7 +132,7 @@ typedef unsigned short                  etap_event_t;
 #include "../h/socketvar.h"
 #include "../h/protosw.h"
 
-#if defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_FBSD_ENV)
 #  include "../h/dirent.h"
 #  ifdef       AFS_SUN5_ENV
 #    include "../h/sysmacros.h"
@@ -184,15 +184,24 @@ struct vfspage;                   /* for vnode.h compiler warnings */
 #    include "../h/swap.h"     /* for struct swpdbd, for vnode.h compiler warnings */
 #    include "../h/dbd.h"      /* for union idbd, for vnode.h compiler warnings */
 #  endif /* AFS_HPUX_ENV */
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD40_ENV)
 #  include <sys/uio.h>
 #  include <sys/mount.h> 
 #  include <sys/namei.h>
 #  include <sys/vnode.h>  
 #  include <sys/queue.h>    
+#ifndef AFS_FBSD_ENV
 #  include <sys/ubc.h>
 #define timeout_fcn_t mach_timeout_fcn_t
 #  include <kern/sched_prim.h>
+#else
+#  include <ufs/ufs/dinode.h>
+#  include <vm/vm.h>
+#  include <vm/vm_extern.h>
+#  include <vm/pmap.h>
+#  include <vm/vm_map.h>
+#  include <sys/lock.h>
+#endif
 #undef timeout_fcn_t
 #define _DIR_H_
 #define doff_t          int32_t
@@ -213,7 +222,7 @@ struct vfspage;                     /* for vnode.h compiler warnings */
 #      endif /* !AFS_HPUX_ENV */
 #    endif /* !AFS_AIX32_ENV */
 #  endif /* AFS_SUN5_ENV */
-#endif /* AFS_DARWIN_ENV */
+#endif /* AFS_DARWIN_ENV || AFS_FBSD_ENV */
 #endif /* AFS_DEC_ENV */
 
 /* These mainly deal with networking and rpc headers */
@@ -234,7 +243,9 @@ struct vfspage;                     /* for vnode.h compiler warnings */
 
 /* Miscellaneous headers */
 #include "../h/proc.h"
+#if !defined(AFS_FBSD_ENV)
 #include "../h/ioctl.h"
+#endif /* AFS_FBSD_ENV */
 
 #if    defined(AFS_HPUX101_ENV)
 #include "../h/proc_iface.h"
@@ -246,7 +257,7 @@ struct vfspage;                     /* for vnode.h compiler warnings */
 #include "../h/tty.h"
 #endif
 
-#if !defined(AFS_SGI_ENV) && !defined(AFS_SUN_ENV) && !defined(AFS_MACH_ENV) && !defined(AFS_AIX32_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_SGI_ENV) && !defined(AFS_SUN_ENV) && !defined(AFS_MACH_ENV) && !defined(AFS_AIX32_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 
 #  include "../h/text.h"
 #endif 
index 2e94d08..6dd79b0 100644 (file)
@@ -106,6 +106,9 @@ install: all
                        ${INSTALL} -f afs.ppc_darwin.plist ${DESTDIR}root.client/usr/vice/etc/afs.kext/Contents/Info.plist ; \
                        ${INSTALLex} -f afs.rc.darwin ${DESTDIR}root.client/usr/vice/etc/afs.rc ; \
                        ${INSTALL} -f afs.rc.darwin.plist ${DESTDIR}root.client/usr/vice/etc/StartupParameters.plist ;; \
+               *fbsd*) \
+                       mkdir -p ${DESTDIR}root.client/usr/vice/etc/afs.rc; \
+                       ${INSTALL} -f afs.rc.fbsd ${DESTDIR}root.client/usr/vice/etc/afs.rc.fbsd ;; \
                * )  \
                        echo No rc scripts installed for ${SYS_NAME} ;; \
        esac
diff --git a/src/afsd/afs.rc.fbsd b/src/afsd/afs.rc.fbsd
new file mode 100644 (file)
index 0000000..c261fc9
--- /dev/null
@@ -0,0 +1,123 @@
+#!/bin/sh
+# 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
+
+. /etc/rc.common
+
+CheckForNetwork 
+
+if [ "${NETWORKUP}" = "-NO-" ]; then exit; fi
+
+if [ -r /var/db/openafs ]; then
+   VICEETC=/var/db/openafs/etc
+   AFSD=/usr/sbin/afsd
+else
+   VICEETC=/usr/vice/etc
+   AFSD=$VICEETC/afsd
+fi
+CONFIG=$VICEETC/config
+AFSDOPT=$CONFIG/afsd.options
+PACKAGE=$CONFIG/package.options
+
+LARGE="-stat 2800 -dcache 2400 -daemons 5 -volumes 128"
+MEDIUM="-stat 2000 -dcache 800 -daemons 3 -volumes 70"
+SMALL="-stat 300 -dcache 100 -daemons 2 -volumes 50"
+
+if [ -f $AFSDOPT ]; then
+    OPTIONS=`cat $AFSDOPT`
+else
+    OPTIONS=$MEDIUM
+fi
+
+# Need the commands ps, awk, kill, sleep
+PATH=${PATH}${PATH:+:}/sbin:/bin:/usr/bin
+if kmodstat | grep -q openafs ; then
+:
+else
+if [ -d $VICEETC/afs.ko ]; then
+       echo "Loading AFS kernel extensions"
+       kldload $VICEETC/afs.ko
+else
+       echo "$VICEETC/afs.ko does not exist. Skipping AFS startup."
+       exit 1
+fi
+fi
+if kldstat | grep -q openafs ; then
+:
+else
+       echo "AFS kernel extensions failed to initialize. Skipping AFS startup."
+fi
+
+#
+# Start the AFS server processes if a bosserver exists
+#
+
+if [ -x /usr/afs/bin/bosserver ]; then
+       echo "Starting AFS Server processes"
+       /usr/afs/bin/bosserver
+       OPTIONS="$OPTIONS -nosettime"
+       sleep 30
+fi
+
+#
+# Check that all of the client configuration files exist
+#
+
+for file in $AFSD $VICEETC/cacheinfo \
+           $VICEETC/ThisCell $VICEETC/CellServDB
+do
+       if [ ! -f ${file} ]; then
+               echo "${file} does not exist. Not starting AFS client."
+               exit 1
+       fi
+done
+
+#
+# Check that the root directory for AFS (/afs) 
+# and the cache directory (/usr/vice/cache) both exist
+#
+
+for dir in `awk -F: '{print $1, $2}' $VICEETC/cacheinfo`
+do
+       if [ ! -d ${dir} ]; then
+               echo "${dir} does not exist. Not starting AFS client."
+               exit 2
+       fi
+done
+
+echo "Starting afsd"
+$AFSD $OPTIONS
+
+#
+# Run package to update the disk
+#
+if [ -f /usr/afsws/etc/package -a -f $PACKAGE ]; then
+       /usr/afsws/etc/package -v -o `cat $PACKAGE` > /dev/console 2>&1
+case $? in
+0)
+       (echo "Package completed successfully") > /dev/console 2>&1
+       date > /dev/console 2>&1
+       ;;
+4)
+       (echo "Rebooting to restart system") > /dev/console 2>&1
+       sync
+       /sbin/reboot
+       ;;
+*)
+       (echo "Package update failed; continuing") > /dev/console 2>&1
+       ;;
+esac
+
+fi
+
+#
+# Start AFS inetd services
+# (See the AFS Command Ref. for notes on the proper configuration of inetd.afs)
+#
+if [ -f /usr/sbin/inetd.afs -a -f /etc/inetd.conf.afs ]; then
+       /usr/sbin/inetd.afs /etc/inetd.conf.afs
+fi
index a3459f9..bf4b9aa 100644 (file)
@@ -93,7 +93,7 @@
 #endif
 #endif
 
-#if defined(AFS_OSF_ENV) || defined(AFS_DEC_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_OSF_ENV) || defined(AFS_DEC_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <sys/mount.h>
 #else
 #include <sys/vfs.h>
@@ -132,7 +132,7 @@ void set_staticaddrs(void);
 #if AFS_HAVE_STATVFS
 #include <sys/statvfs.h>
 #else
-#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #include <sys/statfs.h>
 #endif
 #endif
@@ -1343,6 +1343,9 @@ mainproc(as, arock)
 #ifdef AFS_DEC_ENV
     if ((mount("AFS",cacheMountDir,mountFlags,GT_AFS,(caddr_t) 0)) < 0) {
 #else
+#ifdef AFS_FBSD_ENV
+    if ((mount("AFS",cacheMountDir,mountFlags,(caddr_t) 0)) < 0) {
+#else
 #ifdef AFS_AUX_ENV
     if ((fsmount(MOUNT_AFS,cacheMountDir,mountFlags,(caddr_t) 0)) < 0) {
 #else
@@ -1380,7 +1383,6 @@ mainproc(as, arock)
 #else
 #if defined(AFS_SGI_ENV)
     mountFlags = MS_FSS;
-
     if ((mount(MOUNT_AFS,cacheMountDir,mountFlags,(caddr_t) MOUNT_AFS)) < 0) {
 #else
 #ifdef AFS_LINUX20_ENV
@@ -1395,6 +1397,7 @@ mainproc(as, arock)
 #endif /* AFS_HPUX_ENV */
 #endif /* AFS_AIX_ENV */
 #endif /* AFS_AUX_ENV */
+#endif /* AFS_FBSD_ENV */
 #endif /* AFS_DEC_ENV */
          printf("%s: Can't mount AFS on %s(%d)\n",
                   rn, cacheMountDir, errno);
index 7d62124..89d9c2c 100644 (file)
@@ -1722,7 +1722,7 @@ int a_newProbeCycle;      /* start of a new probe cycle ? */
    }
 
    /* copy connection information */
-#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
    bcopy(&(xstat_fs_Results.connP->skt), &(tmp_fsPR->connP->skt), 
                sizeof(struct sockaddr_in));
 #else
@@ -2454,7 +2454,7 @@ int a_newProbeCycle;      /* start of new probe cycle ? */
 
 
    /* copy connection information */
-#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
    bcopy(&(xstat_cm_Results.connP->skt), &(tmp_cmPR->connP->skt), 
                sizeof(struct sockaddr_in));
 #else
diff --git a/src/config/Makefile.i386_fbsd_42 b/src/config/Makefile.i386_fbsd_42
new file mode 100644 (file)
index 0000000..942d7c7
--- /dev/null
@@ -0,0 +1,52 @@
+# Copyright 1998 Transarc Corporation 
+#
+# Keep macros within each section in sorted order for clean diff displays.
+#
+# AFS_OSTYPE used to indicate suffixes and os specific subdirectories.
+AFS_OSTYPE = FBSD
+# Pointers to destination and source directories
+DESTDIR=DEST/
+SRCDIR=DEST/
+# Base directory for linux kernel source. Actually a prefix which is complete
+# when LINUX_VERS is appended to it.
+# LINUX_SRCDIR = /usr/src/linux-
+# Default list of Linux kernels to build. Build will run only if all
+# can be built. To build a different set, specify LINUX_VERS to make.
+# LINUX_VERS = 2.2.5-15 2.2.10 2.2.12 2.2.12-20 2.2.13 2.2.14
+
+#
+# compilation and link editor flags
+DBG=-g
+OPTMZ=-O2
+PAM_CFLAGS = -O2 -pipe -fPIC
+# Put -O2 here to _ensure_ all Makefiles pick it up.
+XCFLAGS= -O2 -pipe
+MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
+XLDFLAGS=
+SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_SUFFIX=so
+SHLIB_CFLAGS=
+#
+# libraries
+MTLIBS=-pthread
+TXLIBS= /usr/lib/libncurses.so
+XLIBS=-lcompat
+#
+# programs
+AR=ar
+AS=as
+CP=cp
+INSTALL=${SRCDIR}bin/install
+LD=ld   
+MT_CC=cc
+MV=mv
+RANLIB=ranlib
+RM=rm
+WASHTOOL=${SRCDIR}bin/washtool
+#
+# Other OS specific requirements
+#
+YACC = bison -y
+LEX = flex -l
+# Used in des library.
+CRYPT_OBJ = crypt.o
index ad80007..0b4ebec 100644 (file)
 #define SYS_NAME_ID_alpha_linux_22      2001
 #define SYS_NAME_ID_alpha_linux_24      2002
 
+#define SYS_NAME_ID_i386_fbsd_42        2100
 
 /*
  * Placeholder to keep system-wide standard flags since this file is included by all 
diff --git a/src/config/param.i386_fbsd_42.h b/src/config/param.i386_fbsd_42.h
new file mode 100644 (file)
index 0000000..217c58a
--- /dev/null
@@ -0,0 +1,136 @@
+#ifndef        _PARAM_FBSD_42_H_
+#define        _PARAM_FBSD_42_H_
+
+#include <sys/param.h>
+
+#define AFS_XBSD_ENV 1             /* {Free,Open,Net}BSD */
+#define AFS_X86_XBSD_ENV 1
+
+#define AFS_FBSD_ENV 1
+#define AFS_FBSD40_ENV 1
+#define AFS_FBSD42_ENV 1
+#define AFS_X86_FBSD_ENV 1
+#define AFS_X86_FBSD40_ENV 1
+#define AFS_X86_FBSD42_ENV 1
+#define AFS_X86_ENV 1
+#define AFS_NONFSTRANS 1
+#define AFS_KERBEROS_ENV
+#define O_SYNC O_FSYNC
+#define FTRUNC O_TRUNC
+
+#define IUPD 0x0010
+#define IACC 0x0020
+#define ICHG 0x0040
+#define IMOD 0x0080
+
+#define IN_LOCK(ip)     lockmgr(&ip->i_lock, LK_EXCLUSIVE, \
+                                (struct simplelock *)0, curproc)
+#define IN_UNLOCK(ip)   lockmgr(&ip->i_lock, LK_RELEASE, \
+                                (struct simplelock *)0, curproc)
+
+#include <afs/afs_sysnames.h>
+
+#define AFS_VM_RDWR_ENV        1
+#define AFS_VFS_ENV    1
+#define AFS_VFSINCL_ENV 1
+#define AFS_GREEDY43_ENV       1
+#define AFS_ENV        1
+#define AFS_MINPHYS_ENV        1
+#define CMUSTD_ENV     1
+
+#define AFS_SYSCALL    210
+#define AFS_MOUNT_AFS  "afs"
+
+#ifndef MOUNT_UFS
+#define MOUNT_UFS 1
+#endif
+
+#ifndef        MOUNT_AFS
+#define        MOUNT_AFS AFS_MOUNT_AFS
+#endif
+#define SYS_NAME       "i386_fbsd_42"
+#define SYS_NAME_ID    SYS_NAME_ID_i386_fbsd_42
+
+#define AFS_HAVE_FFS            1       /* Use system's ffs. */
+#define AFS_HAVE_STATVFS       0       /* System doesn't supports statvfs */
+
+#define AFS_GCPAGS             1       /* if nonzero, garbage collect PAGs */
+#define AFS_3DISPARES   1       /* Utilize the 3 available disk inode spares */
+#define AFS_USE_GETTIMEOFDAY 1  /* use gettimeofday to implement rx clock */
+
+#if    !defined(ASSEMBLER) && !defined(__LANGUAGE_ASSEMBLY__)
+#include <machine/endian.h>
+#if    BYTE_ORDER == BIG_ENDIAN
+#define        AFSBIG_ENDIAN           1
+#else
+#if    BYTE_ORDER == LITTLE_ENDIAN
+#define        AFSLITTLE_ENDIAN        1
+#else
+#error machine/endian.h must define BYTE_ORDER!
+#endif
+#endif
+#endif /* ! ASSEMBLER && ! __LANGUAGE_ASSEMBLY__ */
+
+#define NEARINODE_HINT  1 /* hint to ufs module to scatter inodes on disk*/
+#define nearInodeHash(volid, hval) {                          \
+                unsigned char*  ts = (unsigned char*)&(volid);\
+                for ((hval)=0; ts<(unsigned char*)&(volid)+sizeof(volid);ts++){\
+                    (hval) *= 173;                      \
+                    (hval) += *ts;                      \
+                }                                       \
+                }
+
+/* Extra kernel definitions (from kdefs file) */
+#ifdef _KERNEL
+#define AFS_GLOBAL_SUNLOCK        1
+#define        AFS_VFS34       1       /* What is VFS34??? */
+#define        AFS_SHORTGID    1       /* are group id's short? */
+#define        afsio_iov       uio_iov
+#define        afsio_iovcnt    uio_iovcnt
+#define        afsio_offset    uio_offset
+#define        afsio_seg       uio_segflg
+#define        afsio_resid     uio_resid
+#define        AFS_UIOSYS      UIO_SYSSPACE
+#define        AFS_UIOUSER     UIO_USERSPACE
+#define        AFS_CLBYTES     CLBYTES
+#define        osi_GetTime(x)  microtime(x)
+#define        AFS_KALLOC(x)   kalloc(x)
+#define        AFS_KFREE(x,y)  kfree(x,y)
+#define        v_count         v_usecount
+#define v_vfsp         v_mount
+#define vfs_bsize      mnt_stat.f_bsize
+#define vfs_fsid       mnt_stat.f_fsid
+#define va_nodeid      va_fileid
+#define vfs_vnodecovered mnt_vnodecovered
+#define direct         dirent
+#define vnode_t                struct vnode
+
+#ifndef MUTEX_DEFAULT
+#define MUTEX_DEFAULT   0
+#endif /* MUTEX_DEFAULT */
+
+#ifndef SSYS
+#define SSYS            0x00002
+#endif /* SSYS */
+
+#define p_rcred         p_ucred
+
+#define        VN_RELE(vp)     vrele(((struct vnode *)(vp)))
+#define        VN_HOLD(vp)     VREF(((struct vnode *)(vp)))
+
+#if    !defined(ASSEMBLER) && !defined(__LANGUAGE_ASSEMBLY__)
+enum vcexcl {NONEXCL, EXCL};
+
+#ifdef KERNEL
+#ifndef MIN
+#define MIN(A,B) ((A) < (B) ? (A) : (B))
+#endif
+#ifndef MAX
+#define MAX(A,B) ((A) > (B) ? (A) : (B))
+#endif
+#endif /* KERNEL */
+
+#endif /* ! ASSEMBLER & ! __LANGUAGE_ASSEMBLY__ */
+#endif /* _KERNEL */
+
+#endif /* _PARAM_FBSD_42_H_ */
diff --git a/src/config/param.i386_fbsd_42_usr.h b/src/config/param.i386_fbsd_42_usr.h
new file mode 100644 (file)
index 0000000..184418b
--- /dev/null
@@ -0,0 +1,61 @@
+#ifndef _PARAM_USR_I386_FBSD_42_H_
+#define _PARAM_USR_I386_FBSD_42_H_
+
+
+#define UKERNEL                        1       /* user space kernel */
+#define AFS_ENV                        1
+#define AFS_VFSINCL_ENV         1
+#define AFS_USR_FBSD40_ENV     1
+#define AFS_USR_FBSD42_ENV     1
+#define AFS_USR_FBSD_ENV       1
+#define AFS_NONFSTRANS 1
+#define AFS_KERBEROS_ENV
+
+#define O_SYNC O_FSYNC
+
+#define AFS_MOUNT_AFS "afs"    /* The name of the filesystem type. */
+#define AFS_SYSCALL 210
+#define AFS_64BIT_IOPS_ENV  1
+#define AFS_NAMEI_ENV     1   /* User space interface to file system */
+#include <afs/afs_sysnames.h>
+
+#define AFS_USERSPACE_IP_ADDR 1
+#define RXK_LISTENER_ENV 1
+#define AFS_GCPAGS             0       /* if nonzero, garbage collect PAGs */
+
+
+/* Machine / Operating system information */
+#define SYS_NAME       "i386_fbsd_42"
+#define SYS_NAME_ID    SYS_NAME_ID_i386_fbsd_42
+#define AFSLITTLE_ENDIAN    1
+#define AFS_HAVE_FFS        1       /* Use system's ffs. */
+#define AFS_HAVE_STATVFS    0  /* System doesn't support statvfs */
+#define AFS_VM_RDWR_ENV            1   /* read/write implemented via VM */
+
+#define        afsio_iov       uio_iov
+#define        afsio_iovcnt    uio_iovcnt
+#define        afsio_offset    uio_offset
+#define        afsio_seg       uio_segflg
+#define        afsio_fmode     uio_fmode
+#define        afsio_resid     uio_resid
+#define        AFS_UIOSYS      1
+#define        AFS_UIOUSER     UIO_USERSPACE
+#define        AFS_CLBYTES     MCLBYTES
+#define        AFS_MINCHANGE   2
+#define        VATTR_NULL      usr_vattr_null
+
+#define AFS_DIRENT
+#ifndef CMSERVERPREF
+#define CMSERVERPREF
+#endif
+
+#include <limits.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/mount.h>
+#include <sys/fcntl.h>
+#include <netinet/in.h>
+#include <sys/uio.h>
+#include <sys/socket.h>
+
+#endif /* _PARAM_USR_I386_FBSD_42_H_ */
index e081722..ef61944 100644 (file)
 #ifdef AFS_SUN5_ENV
 #define BSD_COMP
 #endif
+#if defined(AFS_FBSD_ENV)
+#define USE_OLD_TTY
+#endif
 #include <sys/ioctl.h>
 #include <signal.h>
 #include <setjmp.h>
 #endif
 
-#if defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <signal.h>
 #endif
 
@@ -48,7 +51,7 @@ static int intrupt;
 #include <termios.h>
 #endif
 
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <termios.h>
 #endif
 #ifdef AFS_NT40_ENV
@@ -102,7 +105,7 @@ lose:
     return ok;
 }
 
-#if    defined (AFS_AIX_ENV) || defined (AFS_HPUX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if    defined (AFS_AIX_ENV) || defined (AFS_HPUX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 static void catch(int);
 #endif
 
@@ -124,7 +127,7 @@ des_read_pw_string(s,maxa,prompt,verify)
 {
     int ok = 0, cnt1=0;
     char *ptr;
-#if defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     register int fno;
     struct sigaction newsig, oldsig;
     struct termios save_ttyb, ttyb;
@@ -162,7 +165,7 @@ des_read_pw_string(s,maxa,prompt,verify)
        return -1;
     }
 
-#if defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     if ((fi = fopen("/dev/tty", "r")) == NULL)
         return -1;
     setbuf(fi, (char *)NULL);                  /* We don't want any buffering for our i/o. */
@@ -388,7 +391,7 @@ sig_restore()
 #endif
 
 
-#if    defined (AFS_AIX_ENV) || defined (AFS_HPUX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if    defined (AFS_AIX_ENV) || defined (AFS_HPUX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 static void
 catch(int junk)
 {
index df9fb35..8ea21dd 100644 (file)
@@ -20,7 +20,7 @@
 #include "../h/errno.h"
 #endif
 #include "../h/time.h"
-#if defined(AFS_AIX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV)
+#if defined(AFS_AIX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_FBSD_ENV)
 #include "../h/errno.h"
 #else
 #if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
 #include "../afs/sysincludes.h"
 #endif
 #ifndef AFS_SGI64_ENV
+#if defined(AFS_FBSD_ENV)
+#include "../h/lock.h"
+#include "../vm/vm.h"
+#include "../vm/vm_extern.h"
+#include "../vm/pmap.h"
+#include "../vm/vm_map.h"
+#endif /* AFS_FBSD_ENV */
 #include "../h/user.h"
 #endif /* AFS_SGI64_ENV */
 #include "../h/uio.h"
index 3de02c9..f0f9626 100644 (file)
@@ -63,7 +63,7 @@ int MinHours = 0;
 int npwSums = KA_NPWSUMS;               /* needs to be variable sometime */
 
 #include <stdarg.h>
-#if !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #undef vfprintf
 #define vfprintf(stream,fmt,args) _doprnt(fmt,args,stream)
 #endif
index 85e1b55..95ecbfa 100644 (file)
@@ -29,7 +29,7 @@ static char sccsid[] = "@(#)login.c   5.15 (Berkeley) 4/12/86";
  * login -h hostname (for telnetd, etc.)
  */
 #include <afs/param.h>
-#if !defined(AFS_SUN_ENV) && !defined(AFS_AIX_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_SGI_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_SUN_ENV) && !defined(AFS_AIX_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_SGI_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) &&!defined(AFS_FBSD_ENV)
 #include <sys/param.h>
 
 #define quota(a,b,c,d) 0
index b2a822a..23fd0cc 100644 (file)
@@ -179,7 +179,7 @@ afs_int32 ka_UserAuthenticateGeneral (
     }
 #endif
 
-#if !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_USR_LINUX20_ENV)
+#if !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_USR_LINUX20_ENV) && !defined(AFS_FBSD_ENV)
     /* handle smoothly the case where no AFS system calls exists (yet) */
     old = (int (*)())signal(SIGSYS, SIG_IGN);
 #endif
diff --git a/src/libafs/MakefileProto.FBSD b/src/libafs/MakefileProto.FBSD
new file mode 100644 (file)
index 0000000..07759f6
--- /dev/null
@@ -0,0 +1,112 @@
+#/* Copyright (C) 1995, 1989 Transarc Corporation - All rights reserved */
+#
+# MakefileProto for Digital Unix systems
+#
+
+DESTDIR=DEST/
+# include $(DESTDIR)/../obj/config/Makefile.${SYS_NAME}
+
+
+# OS specific object files:
+AFS_OS_OBJS = \
+       osi_groups.o \
+       osi_file.o \
+       osi_inode.o \
+       osi_misc.o \
+       osi_sleep.o \
+       osi_vm.o \
+       osi_vnodeops.o 
+
+AFS_OS_NFSOBJS = \
+       osi_vfsops_nfs.o
+
+AFS_OS_NONFSOBJS = \
+       osi_vfsops.o
+
+
+# System specific build commands and flags
+# KDEFS=-DLANGUAGE_C  -I/usr/sys/include -I../include \
+#       -I/usr/src/sys/${HEADER_RT} -I/usr/src/sys/sys \
+#      -DSWAPTYPE=1 -DUERF -DOSF -DCOMPAT_43 -DUFS \
+#      -DRT -DKERNEL -D_KERNEL
+KDEFS=-Wall -fformat-extensions -ansi -nostdinc -I/usr/include -D_KERNEL \
+       -elf -mpreferred-stack-boundary=2 -I/usr/src/sys/sys -I../afs
+DBUG = -O2
+DEFINES= -DAFSDEBUG -DKERNEL -DAFS -DVICE -DNFS -DUFS -DINET -DQUOTA -DGETMOUNT
+OPTF=${OPT} 
+OPTF2=${OPT2} 
+CFLAGS=-I. -I.. ${FSINCLUDES} $(DEFINES) $(KDEFS) $(KOPTS) ${DBUG}
+
+
+# Name of directory to hold object files and libraries.
+KOBJ = STATIC
+
+# This tells Makefile.common to use it's single directory build target.
+COMPDIRS = single_compdir
+
+include Makefile.common
+
+setup:
+       -mkdir $(KOBJ)
+       -rm $(KOBJ)/Makefile $(KOBJ)/Makefile.common
+       ln -s ../Makefile $(KOBJ)/Makefile
+       ln -s ../Makefile.common $(KOBJ)/Makefile.common
+       -rm -f  h net netinet rpc ufs nfs  machine sys vm
+       -ln -s /usr/src/sys/net net
+       -ln -s /usr/src/sys/i386/include machine
+       -ln -s /usr/src/sys/netinet netinet
+       -ln -s /usr/src/sys/nfs nfs
+       -ln -s /usr/include/rpc rpc
+       -ln -s /usr/src/sys/sys sys
+       -ln -s /usr/src/sys/ufs/ufs ufs
+       -ln -s /usr/src/sys/sys h
+       -ln -s /usr/src/sys/vm vm
+       -touch $(KOBJ)/sec_net.h
+
+
+# Below this line are targets when in the COMMON directory:
+LIBAFS = libafs.o
+LIBAFSNONFS = libafs.nonfs.o
+
+DEST_LIBAFS = ${DESTDIR}/root.client/bin/${LIBAFS}
+DEST_LIBAFSNONFS = ${DESTDIR}/root.client/bin/${LIBAFSNONFS}
+
+
+# libafs:      $(DEST_LIBAFS) $(DEST_LIBAFSNONFS)
+# libafs:      $(DEST_LIBAFSNONFS)
+libafs:
+       echo WARNING: No kernel module for ${SYS_NAME}
+
+
+$(DEST_LIBAFS): $(LIBAFS)
+       $(INSTALL) -f $? $@
+
+$(DEST_LIBAFSNONFS): $(LIBAFSNONFS)
+       $(INSTALL) -f $? $@
+
+${LIBAFS}: $(AFSAOBJS) $(AFSNFSOBJS)
+       $(LD) -r -o ${LIBAFS} ${AFSAOBJS} ${AFSNFSOBJS}
+
+${LIBAFSNONFS}:  $(AFSAOBJS) $(AFSNONFSOBJS)
+       $(LD) -r -o ${LIBAFSNONFS} ${AFSAOBJS} ${AFSNONFSOBJS}
+
+
+# Object build rules:
+osi_groups.o: $(AFS)/osi_groups.c
+       $(CRULE1)
+osi_file.o: $(AFS)/osi_file.c
+       $(CRULE1)
+osi_inode.o: $(AFS)/osi_inode.c
+       $(CRULE1)
+osi_misc.o: $(AFS)/osi_misc.c
+       $(CRULE1)
+osi_sleep.o: $(AFS)/osi_sleep.c
+       $(CRULE1)
+osi_vfsops_nfs.o: $(AFS)/osi_vfsops.c
+       $(CRULE1) -o osi_vfsops_nfs.o
+osi_vfsops.o: $(AFS)/osi_vfsops.c
+       $(CRULE1) -DAFS_NONFSTRANS
+osi_vm.o: $(AFS)/osi_vm.c
+       $(CRULE1)
+osi_vnodeops.o: $(AFS)/osi_vnodeops.c
+       $(CRULE1)
index add1ed1..543e3c0 100644 (file)
@@ -326,6 +326,8 @@ syscall.o: ${SYS}/syscall.s
                ${AS} -P ${CFLAGS} -D_NO_PROTO -DMACH -DOSF -nostdinc -traditional -DASSEMBLER ${SYS}/syscall.s; \
                ${AS} -o syscall.o syscall.i; \
                rm -f syscall.ss syscall.i;; \
+        *fbsd* ) \
+               touch syscall.o ;; \
         *) \
                /lib/cpp  ${SFLAGS} ${SYS}/syscall.s syscall.ss; \
                as -o syscall.o syscall.ss;             \
diff --git a/src/libuafs/MakefileProto.FBSD b/src/libuafs/MakefileProto.FBSD
new file mode 100644 (file)
index 0000000..d493755
--- /dev/null
@@ -0,0 +1,76 @@
+#/* Copyright (C) 1995, 1989 Transarc Corporation - All rights reserved */
+# 
+# MakefileProto for Solaris systems
+#
+
+include ../config/Makefile.${SYS_NAME}
+
+MKDIR_IF_NEEDED=[ -d $$1 ] || mkdir -p $$1
+
+# System specific build commands and flags
+CC = gcc
+DEFINES= -D_REENTRANT -DAFSDEBUG -DKERNEL -DUKERNEL -DAFS -DVICE
+KOPTS=
+CFLAGS=-I. -I.. ${FSINCLUDES} $(DEFINES) $(KOPTS) ${DBUG}
+OPTF=-O
+# WEBOPTS = -I../nsapi -DNETSCAPE_NSAPI -DNET_SSL -DXP_UNIX -DMCC_HTTPD
+
+TEST_CFLAGS=-pthread -D_REENTRANT -DAFS_PTHREAD_ENV -DAFS_FBSD40_ENV
+TEST_LDFLAGS=
+TEST_LIBS=
+
+LIBUAFS = libuafs.a
+LIBAFSWEB = nsafs.so
+LIBAFSWEBKRB = nsafs.krb.so
+
+include Makefile.common
+
+setup_common:
+       -rm -f  h net netinet rpc ufs nfs  machine sys inet nsapi
+       -ln -s /usr/include/sys h
+       -ln -s /usr/include/net net
+       -ln -s /usr/include/netinet netinet
+       -ln -s /usr/include/rpc rpc
+       -ln -s /usr/include/sys sys
+       -ln -s /usr/include/nfs nfs
+       -ln -s /usr/include/inet inet
+       -ln -s /usr/include/ufs ufs
+       -ln -s $(NS_INCL) nsapi
+
+setup_uafs: setup_common
+       set UAFS; $(MKDIR_IF_NEEDED)
+       -rm -f UAFS/Makefile UAFS/Makefile.common
+       ln -s ../Makefile UAFS/Makefile
+       ln -s ../Makefile.common UAFS/Makefile.common
+
+setup_nsafs: setup_common
+       set AFSWEB; $(MKDIR_IF_NEEDED)
+       -rm -f AFSWEB/Makefile AFSWEB/Makefile.common
+       ln -s ../Makefile AFSWEB/Makefile
+       ln -s ../Makefile.common AFSWEB/Makefile.common
+
+UAFS/$(LIBUAFS): setup_uafs
+       cd UAFS; \
+       $(MAKE) $(LIBUAFS) DESTDIR=${DESTDIR}
+
+AFSWEB/$(LIBAFSWEB): setup_nsafs
+cd AFSWEB; \
+       $(MAKE) $(LIBAFSWEB) DESTDIR=${DESTDIR}
+
+AFSWEB/$(LIBAFSWEBKRB): setup_nsafs
+       cd AFSWEB; \
+       $(MAKE) $(LIBAFSWEBKRB) DESTDIR=${DESTDIR}
+
+# Below this line are targets when in the COMMON directory:
+
+$(LIBUAFS): $(UAFSOBJ)
+       -rm -f $(LIBUAFS)
+       $(AR) $(ARFLAGS) $(LIBUAFS) $(UAFSOBJ)
+
+$(LIBAFSWEB): $(AFSWEBOBJ) ${DES}/libdes.a
+       -rm -f $(LIBAFSWEB)
+       ld -b $(LIBAFSWEB) $(AFSWEBOBJ) ${DES}/libdes.a $(WEBLIBS)
+
+$(LIBAFSWEBKRB): $(AFSWEBOBJKRB) ${DES}/libdes.a
+       -rm -f $(LIBAFSWEBKRB)
+       ld -b $(LIBAFSWEBKRB) $(AFSWEBOBJKRB) ${DES}/libdes.a $(WEBLIBS)
index 56ba397..5290524 100644 (file)
@@ -53,6 +53,8 @@ char copyright[] =
 #if  !defined(AFS_HPUX_ENV) && !defined(AFS_AIX_ENV)
 #if defined(AFS_SUN_ENV) || (defined(AFS_ATHENA_STDENV) && !defined(AFS_DEC_ENV)) || defined(AFS_OSF_ENV)
 #include <ufs/quota.h>
+#elif defined(AFS_FBSD_ENV)
+#include <ufs/ufs/quota.h>
 #else
 #include <sys/quota.h>
 #endif
@@ -71,6 +73,10 @@ char copyright[] =
 #include <sys/ttold.h>
 #include <sys/filio.h>
 #endif
+#ifdef AFS_FBSD_ENV
+#define USE_OLD_TTY 1
+#include <sys/ttydefaults.h>
+#endif
 #include <sys/ioctl.h>
 
 #include <utmp.h>
@@ -79,7 +85,7 @@ char copyright[] =
 #include <dirent.h>
 #endif
 #include <signal.h>
-#if !defined(AIX) && !defined(AFS_HPUX_ENV) && !defined(AFS_AIX32_ENV)
+#if !defined(AIX) && !defined(AFS_HPUX_ENV) && !defined(AFS_AIX32_ENV) && !defined(AFS_FBSD_ENV)
 #include <lastlog.h>
 #endif
 #include <errno.h>
index 022145f..9e44ef5 100644 (file)
@@ -69,7 +69,11 @@ process.o    : process.s process.c
                                        rm process.ss ;; \
                                ppc_darwin* ) \
                                        $(CC) -c ${XCFLAGS} -I${SRCDIR}include process.s;; \
-                               hp* | *_linux* | sgi_64 | sgi_65) \
+                               i386_fbsd* ) \
+                                       /usr/bin/cpp -P process.fbsd.s > process.ss; \
+                                       ${AS} -o process.o process.ss; \
+                                       rm process.ss ;; \
+                               hp* | *_linux* | sgi_64 | sgi_65 ) \
                                        ${CC} ${CFLAGS} -c process.c;; \
                                ncrx86_*) \
                                        /usr/ccs/lib/cpp -P -I${SRCDIR}include process.s process.ss; \
index 4b9e42b..1a40ca8 100644 (file)
@@ -343,7 +343,7 @@ int LWP_CreateProcess(ep, stacksize, priority, parm, name, pid)
 #ifdef __hp9000s800
        savecontext(Create_Process_Part2, &temp2->context, stackptr+MINFRAME);
 #else
-#if defined(AFS_SGI62_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SGI62_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
        /* Need to have the sp on an 8-byte boundary for storing doubles. */
        savecontext(Create_Process_Part2, &temp2->context,
                    stackptr+stacksize-16); /* 16 = 2 * jmp_buf_type*/
@@ -485,7 +485,7 @@ int LWP_DestroyProcess(pid)         /* destroy a lightweight process */
            savecontext(Dispatcher, &(temp -> context),
                        &(LWPANCHOR.dsptchstack[MINFRAME]));
 #else
-#if defined(AFS_SGI62_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SGI62_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
            savecontext(Dispatcher, &(temp -> context),
                        &(LWPANCHOR.dsptchstack[(sizeof LWPANCHOR.dsptchstack)-8]));
 #else
index e95dacb..0b2bf52 100644 (file)
@@ -17,7 +17,7 @@
 \*******************************************************************/
 #include <afs/param.h>
 
-#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 int PRE_Block = 0;
 #else
 #include <sys/time.h>
index 155d60b..32aa938 100644 (file)
@@ -50,6 +50,8 @@ extern char PRE_Block;             /* used in lwp.c and process.s */
 #else
 #error Unsupported linux LWP system type.
 #endif
+#elif   defined(AFS_X86_FBSD_ENV)
+#define LWP_SP 4
 #elif   defined(AFS_DARWIN_ENV)
 #define LWP_SP 16
 #else
diff --git a/src/lwp/process.fbsd.s b/src/lwp/process.fbsd.s
new file mode 100644 (file)
index 0000000..18dcacf
--- /dev/null
@@ -0,0 +1,90 @@
+/*
+ * 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
+ */
+
+#define        IGNORE_STDS_H   1
+/* Sun 386i... I hope this does the right thing!!!
+ * 
+ * Written by Derek Atkins <warlord@MIT.EDU>
+ * (debugging help by Chris Provenzano <proven@mit.edu>)
+ * 11/1991
+ *
+ * "ojala que es correcto!"
+ */
+       .file "process.s"
+
+       .data
+
+       .text
+
+/*
+ * struct savearea {
+ *     char    *topstack;
+ * }
+ */
+
+       .set    topstack,0
+
+/*
+ * savecontext(f, area1, newsp)
+ *     int (*f)(); struct savearea *area1; char *newsp;
+ */
+
+/* offsets, to make my life easier! */
+       .set    f,8
+       .set    area1,12
+       .set    newsp,16
+
+
+.globl PRE_Block
+.globl savecontext
+
+savecontext:
+       pushl   %ebp                    /* New Frame! */
+       movl    %esp,%ebp
+       pusha                           /* Push all registers */
+       movl    $1,PRE_Block            /* Pre-emption code */
+       movl    area1(%ebp),%eax        /* eax = base of savearea */
+       movl    %esp,(%eax)             /* area->topstack = esp */
+       movl    newsp(%ebp),%eax        /* get new sp into eax */
+       cmpl    $0,%eax
+       je      L1                      /* if new sp is 0 then dont change esp */
+       movl    %eax,%esp               /* go ahead.  make my day! */
+L1:
+       jmp     *f(%ebp)                        /* ebx = &f */
+
+/* Shouldnt be here....*/
+
+       call    abort
+
+/*
+ * returnto(area2)
+ *     struct savearea *area2;
+ */
+
+/* stack offset */
+       .set    area2,8
+
+.globl returnto
+
+returnto:
+       pushl   %ebp
+       movl    %esp, %ebp              /* New frame, to get correct pointer */
+       movl    area2(%ebp),%eax        /* eax = area2 */
+       movl    (%eax),%esp             /* restore esp */
+       popa 
+       movl    $0,PRE_Block            /* clear it up... */
+       popl    %ebp
+       ret
+
+/* I see, said the blind man, as he picked up his hammer and saw! */
+       pushl   $1234
+       call    abort
+
+
+
index 1efa91b..09de7e6 100644 (file)
@@ -52,7 +52,7 @@ typedef unsigned char bool;
 
 static globalInitDone = 0;
 
-#if !defined(AFS_HPUX_ENV) && !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV)
+#if !defined(AFS_HPUX_ENV) && !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV)
 extern insque();
 #endif
 
@@ -256,7 +256,7 @@ struct TM_Elem *TM_GetEarliest(tlist)
     return (e == tlist ? NULL : e);
 }
 
-#if defined(AFS_HPUX_ENV) || defined(AFS_NT40_ENV)
+#if defined(AFS_HPUX_ENV) || defined(AFS_NT40_ENV) || defined(AFS_FBSD_ENV)
 /* This used to be in hputils.c, but it's only use is in the LWP package. */
 /*
  * Emulate the vax instructions for queue insertion and deletion, somewhat.
@@ -285,4 +285,4 @@ void remque(struct TM_Elem *elementp)
     elementp->Prev = elementp->Next = (struct TM_Elem*)0;
 }
 
-#endif /* AFS_HPUX_ENV || AFS_NT40_ENV */
+#endif /* AFS_HPUX_ENV || AFS_NT40_ENV || AFS_FBSD_ENV */
index fd9f615..fc7be40 100644 (file)
@@ -154,7 +154,7 @@ int LWP_WaitForKeystroke(int seconds)
     if (stdin->_IO_read_ptr < stdin->_IO_read_end)
        return 1;
 #else
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     if (stdin->_bf._size > 0)
         return 1;
 #else
index 7110721..4dd02e3 100644 (file)
@@ -26,7 +26,7 @@
 
 char *emalloc();
 
-#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV)
+#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_FBSD_ENV)
 int test_linecounter;  /*Line number currently being parsed*/
 char *ch2str();
 char *appendchtostr();
index 2d52a99..6bc69c8 100644 (file)
@@ -28,7 +28,7 @@
 
 char *emalloc();
 
-#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV)
+#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_FBSD_ENV)
 int test_linecounter;  /*Line number currently being parsed*/
 
 char *ch2str();
index eb37016..9b218cb 100644 (file)
@@ -52,6 +52,8 @@ pam_afs.so.1: $(SHOBJS) afs_setcred.o
                        $(SHOBJS) $(LIBS) ;; \
        *linux*) \
                $(CC) $(LDFLAGS) -o $@ afs_setcred.o $(SHOBJS) $(LIBS) ;;\
+       *fbsd*) \
+               $(CC) $(LDFLAGS) -o $@ afs_setcred.o $(SHOBJS) $(LIBS) ;;\
        * ) \
                echo No link line for system $(SYS_NAME). ;; \
        esac
@@ -67,6 +69,8 @@ pam_afs.krb.so.1: $(SHOBJS) afs_setcred_krb.o
                        afs_setcred_krb.o $(SHOBJS) $(LDFLAGS) $(KLIBS) ;; \
        *linux*) \
                $(CC) $(LDFLAGS) -o $@ afs_setcred_krb.o $(SHOBJS) $(KLIBS) ;;\
+       *fbsd*) \
+               $(CC) $(LDFLAGS) -o $@ afs_setcred_krb.o $(SHOBJS) $(KLIBS) ;;\
        * ) \
                echo No link line for system $(SYS_NAME). ;; \
        esac
@@ -80,6 +84,8 @@ test_pam: test_pam.o
                $(CC) $(CFLAGS) -o $@ test_pam.o ${PAMLIBS};; \
        *linux*) \
                $(CC) $(CFLAGS) -rdynamic -o $@ test_pam.o -lpam -ldl;; \
+       *fbsd*) \
+               $(CC) $(CFLAGS) -rdynamic -o $@ test_pam.o -lpam ;; \
        *) \
                echo No link line for system $(SYS_NAME). ;; \
        esac
index f5c928e..1939437 100644 (file)
@@ -29,7 +29,7 @@ static const char *service = "afstest";
 static const char *new_envstring = "GOTHEREVIATESTPAM=1";
 static const char *new_homestring = "HOME=/tmp";
 
-#ifdef AFS_LINUX20_ENV
+#if defined(AFS_LINUX20_ENV) || defined(AFS_FBSD_ENV)
 #define getpassphrase getpass
 #endif
 
index e9f811c..53e4ed8 100644 (file)
@@ -82,7 +82,7 @@ struct stat istat, ostat;
 
 extern int errno;
 extern int sys_nerr;
-#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD40_ENV)
 extern char *sys_errlist[];
 #endif
 #if    defined(AFS_AIX_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DECOSF_ENV) || defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
index bf7db5b..a11c525 100644 (file)
@@ -78,7 +78,7 @@ static char sccsid[] = "@(#)rcp.c     5.11 (Berkeley) 9/22/88";
 int    rem;
 char   *colon(), *index(), *rindex(), *malloc(), *strcpy();
 int    errs;
-#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 extern char *sys_errlist[];
 #endif
 void   lostconn();
index 9109b96..c043e1c 100644 (file)
@@ -97,7 +97,7 @@ rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
 #endif
        char **ahost;
         u_short rport;
-#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
        const char *locuser, *remuser, *cmd;
 #else
        char *locuser, *remuser, *cmd;
@@ -359,7 +359,7 @@ rresvport(alport)
 
 int    _check_rhosts_file = 1;
 
-#if defined(AFS_HPUX102_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_HPUX102_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 ruserok(rhost, superuser, ruser, luser)
         const char *rhost;
         int superuser;
diff --git a/src/rx/FBSD/rx_kmutex.h b/src/rx/FBSD/rx_kmutex.h
new file mode 100644 (file)
index 0000000..924d8c2
--- /dev/null
@@ -0,0 +1,96 @@
+/* Copyright Transarc Corporation 1998 - All Rights Reserved
+ *
+ * rx_kmutex.h - mutex and condition variable macros for kernel environment.
+ *
+ * DUX implementation.
+ */
+
+#ifndef _RX_KMUTEX_H_
+#define _RX_KMUTEX_H_
+
+#ifdef AFS_FBSD40_ENV
+
+#include <sys/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 {
+    struct simplelock lock;
+} 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); \
+    } while(0);
+#define MUTEX_INIT(a,b,c,d) \
+    do { \
+       usimple_lock_init(&(a)->lock); \
+    } while(0);
+#define MUTEX_DESTROY(a) \
+    do { \
+       usimple_lock_terminate(&(a)->lock); \
+    } while(0);
+#define MUTEX_ENTER(a) \
+    do { \
+       usimple_lock(&(a)->lock); \
+    } while(0);
+#define MUTEX_TRYENTER(a) \
+   usimple_lock(&(a)->lock)
+#define MUTEX_EXIT(a) \
+    do { \
+       usimple_unlock(&(a)->lock); \
+    } while(0);
+
+#undef MUTEX_ISMINE
+#define MUTEX_ISMINE(a) 1
+/* 
+  #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 /* FBSD40 */
+
+
+#endif /* _RX_KMUTEX_H_ */
+
diff --git a/src/rx/FBSD/rx_knet.c b/src/rx/FBSD/rx_knet.c
new file mode 100644 (file)
index 0000000..30ae839
--- /dev/null
@@ -0,0 +1,361 @@
+/*
+****************************************************************************
+*        Copyright IBM Corporation 1988, 1989 - All Rights Reserved        *
+*        Copyright Transarc Corporation 1989 - All Rights Reserved         *
+*                                                                          *
+* Permission to use, copy, modify, and distribute this software and its    *
+* documentation for any purpose and without fee is hereby granted,         *
+* provided that the above copyright notice appear in all copies and        *
+* that both that copyright notice and this permission notice appear in     *
+* supporting documentation, and that the name of IBM not be used in        *
+* advertising or publicity pertaining to distribution of the software      *
+* without specific, written prior permission.                              *
+*                                                                          *
+* IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL *
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL IBM *
+* BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY      *
+* DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER  *
+* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING   *
+* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.    *
+****************************************************************************
+*/
+
+#include "../afs/param.h"
+#ifdef AFS_FBSD40_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 */
+rxk_init() {
+    register struct protosw *tpro, *last;
+    if (rxk_initDone) return 0;
+
+    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;  
+          bcopy(tpro, &parent_proto, 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 0;
+      }
+    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, (struct mbuf *)0);
+        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. */
+                       memset(tvu->ui_i.ih_x1, 0, 9);
+                       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;
+               AFS_RXGLOCK();
+               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);
+               AFS_RXGUNLOCK();
+               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(asocket, addr, dvec, nvec, asize, istack)
+     register struct socket *asocket;
+     struct iovec *dvec;
+     int nvec;
+     register afs_int32 asize;
+     struct sockaddr_in *addr;
+     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 = (struct ifnet *)0;
+        } 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);
+         bcopy(tdata, tpa, 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 = (struct mbuf *) 0;
+
+    /* 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;
+    }
+    bcopy(addr, mtod(um, caddr_t), 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); */
+    code = (*asocket->so_proto->pr_usrreqs->pru_send)(asocket, 0, tm, 
+                                                     (struct sockaddr *) addr,
+                                                     um, curproc);
+    /* SOCKET_UNLOCK(asocket); */
+    /* if (haveGlock) {
+       AFS_GLOCK();
+       } */
+    splx(s);
+    m_free(um);
+
+    return code;
+}
+
+#endif /* AFS_FBSD40_ENV */
index e0a5191..1056e22 100644 (file)
@@ -122,6 +122,8 @@ kinstall: includes
        case ${SYS_NAME} in \
        alpha_dux* ) \
                $(INSTALL) DUX/*.[ch] $(KERNELDIR)rx;; \
+       i386_fbsd* ) \
+               $(INSTALL) FBSD/*.[ch] $(KERNELDIR)rx;; \
        *_linux* ) \
                $(INSTALL) LINUX/*.[ch] $(KERNELDIR)rx;; \
        rs_aix* ) \
index 5a0c41a..1432d6e 100644 (file)
 #include <net/if.h>
 #include <netinet/in.h>
 #include <sys/ioctl.h>
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <sys/sysctl.h>
 #include <net/route.h>
 #include <net/if_dl.h>
 #endif
+
 /*
  * By including this, we get any system dependencies. In particular,
  * the pthreads for solaris requires the socket call to be mapped.
@@ -105,7 +106,7 @@ afs_int32 rxi_getaddr ()
 #undef socket
 #endif /* UKERNEL */
 
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #define ROUNDUP(a) \
         ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
 #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
@@ -132,7 +133,7 @@ rt_xaddrs(cp, cplim, rtinfo)
 /* this function returns the total number of interface addresses 
 ** the buffer has to be passed in by the caller
 */
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 int rx_getAllAddr (buffer,maxSize)
 afs_int32      buffer[];
 int    maxSize;        /* sizeof of buffer in afs_int32 units */
@@ -337,13 +338,13 @@ int    maxSize;        /* sizeof of buffer in afs_int32 units */
     len = ifc.ifc_len / sizeof(struct ifreq);
     if (len > NIFS)
        len = NIFS;
-#if    defined(AFS_AIX41_ENV) || defined (AFS_DARWIN_ENV)
+#if    defined(AFS_AIX41_ENV) || defined (AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     if ( ifc.ifc_len > sizeof(ifs) )   /* safety check */
        ifc.ifc_len = sizeof(ifs); 
     for ( cp = (char *)ifc.ifc_buf, 
                cplim= ifc.ifc_buf+ifc.ifc_len;
                cp < cplim;
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
                cp += _SIZEOF_ADDR_IFREQ(*ifr))
 #else
                 cp += sizeof(ifr->ifr_name) + MAX(a->sin_len, sizeof(*a)))
index a07dad1..73a140e 100644 (file)
@@ -423,7 +423,7 @@ register struct rx_peer *pp;
  */
 
 
-#if ! defined(AFS_AIX_ENV) && ! defined(AFS_SUN5_ENV) && ! defined(UKERNEL) && ! defined(AFS_LINUX20_ENV) && !defined (AFS_DARWIN_ENV)
+#if ! defined(AFS_AIX_ENV) && ! defined(AFS_SUN5_ENV) && ! defined(UKERNEL) && ! defined(AFS_LINUX20_ENV) && !defined (AFS_DARWIN_ENV) && !defined (AFS_FBSD_ENV)
 /* Routine called during the afsd "-shutdown" process to put things back to
  * the initial state.
  */
@@ -548,7 +548,7 @@ afs_int32 rxi_Findcbi(addr)
 
 #else /* AFS_USERSPACE_IP_ADDR */
 
-#if !defined(AFS_AIX41_ENV) && !defined(AFS_DUX40_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_AIX41_ENV) && !defined(AFS_DUX40_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #define IFADDR2SA(f) (&((f)->ifa_addr))
 #else /* AFS_AIX41_ENV */
 #define IFADDR2SA(f) ((f)->ifa_addr)
@@ -569,14 +569,14 @@ int rxi_GetIFInfo()
     bzero(addrs, sizeof(addrs));
     bzero(mtus, sizeof(mtus));
 
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     TAILQ_FOREACH(ifn, &ifnet, if_link) {
       if (i >= ADDRSPERSITE) break;
 #else 
     for (ifn = ifnet; ifn != NULL && i < ADDRSPERSITE; ifn = ifn->if_next) {
 #endif
       rxmtu = (ifn->if_mtu - RX_IPUDP_SIZE);
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
       TAILQ_FOREACH(ifad, &ifn->if_addrhead, ifa_link) {
       if (i >= ADDRSPERSITE) break;
 #else
@@ -636,7 +636,7 @@ rxi_FindIfnet(addr, pifad)
 
   /* if we're given an address, skip everything until we find it */
   if (!*pifad)
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     *pifad = TAILQ_FIRST(&in_ifaddrhead);
 #else 
     *pifad = in_ifaddr;
@@ -644,14 +644,14 @@ rxi_FindIfnet(addr, pifad)
   else {
     if (((ppaddr & (*pifad)->ia_subnetmask) == (*pifad)->ia_subnet))
       match_value = 2; /* don't find matching nets, just subnets */
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     *pifad = TAILQ_NEXT(*pifad, ia_link);
 #else   
     *pifad = (*pifad)->ia_next;
 #endif
   }
     
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
   for (ifa = *pifad; ifa; ifa = TAILQ_NEXT(ifa, ia_link) ) {
 #else
   for (ifa = *pifad; ifa; ifa = ifa->ia_next ) {
@@ -713,7 +713,7 @@ struct osi_socket *rxk_NewSocket(short aport)
 #endif
 
     AFS_STATCNT(osi_NewSocket);
-#if defined(AFS_DARWIN_ENV) && defined(KERNEL_FUNNEL)
+#if (defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)) && defined(KERNEL_FUNNEL)
     thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);
 #endif
 #if    defined(AFS_HPUX102_ENV)
@@ -726,6 +726,8 @@ struct osi_socket *rxk_NewSocket(short aport)
 #else
 #ifdef AFS_SGI65_ENV
     code = socreate(AF_INET, &newSocket, SOCK_DGRAM,IPPROTO_UDP);
+#elif defined(AFS_FBSD_ENV)
+    code = socreate(AF_INET, &newSocket, SOCK_DGRAM,IPPROTO_UDP, curproc);
 #else
     code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0);
 #endif /* AFS_SGI65_ENV */
@@ -760,9 +762,13 @@ struct osi_socket *rxk_NewSocket(short aport)
        if (code)
            osi_Panic("osi_NewSocket: last attempt to reserve 32K failed!\n");
     }
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     myaddr.sin_len = sizeof(myaddr);
+#if defined(AFS_FBSD_ENV)
+    code = sobind(newSocket, (struct sockaddr *)&myaddr, curproc);
+#else
     code = sobind(newSocket, (struct sockaddr *)&myaddr);
+#endif
     if (code) {
         printf("sobind fails\n");
         soclose(newSocket);
@@ -775,7 +781,7 @@ struct osi_socket *rxk_NewSocket(short aport)
     nam = m_get(M_WAIT, MT_SONAME);
 #endif
     if (nam == NULL) {
-#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV)
+#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_FBSD_ENV)
        setuerror(ENOBUFS);
 #endif
        goto bad;
@@ -789,6 +795,8 @@ struct osi_socket *rxk_NewSocket(short aport)
     BHV_PDATA(&bhv) = (void*)newSocket;
     code = sobind(&bhv, nam);
     m_freem(nam);
+#elif defined(AFS_FBSD_ENV)
+    code = sobind(newSocket, nam, curproc);
 #else
     code = sobind(newSocket, nam);
 #endif
@@ -988,7 +996,7 @@ void rxk_Listener(void)
 #ifdef AFS_SUN5_ENV
     rxk_ListenerPid = ttoproc(curthread)->p_pidp->pid_id;
 #endif /* AFS_SUN5_ENV */
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
     rxk_ListenerPid = current_proc()->p_pid;
 #endif
 #if defined(RX_ENABLE_LOCKS) && !defined(AFS_SUN5_ENV)
@@ -1030,7 +1038,7 @@ void rxk_Listener(void)
 #endif /* AFS_SUN5_ENV */
 }
 
-#if !defined(AFS_LINUX20_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_LINUX20_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 /* The manner of stopping the rx listener thread may vary. Most unix's should
  * be able to call soclose.
  */
index 9f01116..389d66a 100644 (file)
@@ -35,11 +35,19 @@ typedef unsigned short                  etap_event_t;
 #ifndef AFS_LINUX22_ENV
 #include "../h/socketvar.h"
 #include "../h/protosw.h"
-#ifndef AFS_SUN5_ENV
+#if !defined(AFS_SUN5_ENV) && !defined(AFS_FBSD_ENV)
 #include "../h/domain.h"
 #include "../h/dir.h"
 #include "../h/buf.h"
 #include "../h/mbuf.h"
+#else
+#if defined(AFS_FBSD_ENV)
+#include "../h/dirent.h"
+#include "../h/socket.h"
+#include "../h/domain.h"
+#include "../h/buf.h"
+#include "../h/mbuf.h"
+#endif /* AFS_FBSD_ENV */
 #endif
 #endif /* AFS_LINUX22_ENV */
 #ifdef AFS_SGI62_ENV
@@ -106,4 +114,8 @@ extern struct ifnet *rxi_FindIfnet();
 
 extern int rxk_initDone;
 
+#if defined(AFS_FBSD_ENV)
+extern struct domain inetdomain;
+#endif /* AFS_FBSD_ENV */
+
 #endif /* _RX_KCOMMON_H_ */
index 6b2af42..cb49d1e 100644 (file)
@@ -40,7 +40,7 @@
 #define MAX(a,b)  ((a)>(b)?(a):(b))
 #endif
 #else /* AFS_NT40_ENV */
-#if !defined(AFS_DARWIN_ENV) && !defined(AFS_USR_DARWIN_ENV)
+#if !defined(AFS_DARWIN_ENV) && !defined(AFS_USR_DARWIN_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_USR_FBSD_ENV)
 #include <sys/sysmacros.h>      /* MIN, MAX on Solaris */
 #endif
 #include <sys/param.h>          /* MIN, MAX elsewhere */
index 0685433..0b40990 100644 (file)
@@ -10,7 +10,7 @@
 #ifdef KERNEL
 #include "../afs/param.h"
 #ifndef UKERNEL
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include "../afs/sysincludes.h"
 #else
 #include "../h/types.h"
index b4a6bcc..e96aba4 100644 (file)
@@ -88,6 +88,8 @@ int debug = 0;
 static char *cmdname;
 #ifdef AFS_SUN5_ENV
 static char CPP[] = "/usr/ccs/lib/cpp";
+#elif defined(AFS_FBSD_ENV)
+static char CPP[] = "/usr/bin/cpp";
 #elif defined(AFS_NT40_ENV)
 static char CPP[MAXCMDLINE];
 #elif defined(AFS_DARWIN_ENV)
index 22c1672..72267e6 100644 (file)
@@ -87,6 +87,8 @@ syscall.o: syscall.s
                rm -f syscall.ss syscall.i;; \
         hp_ux11? ) \
                touch syscall.o;; \
+       i386_fbsd* ) \
+               touch syscall.o;; \
         *) \
                /lib/cpp  ${SFLAGS} syscall.s syscall.ss; \
                as -o syscall.o syscall.ss;             \
index ee9a2ad..0b22fac 100644 (file)
@@ -60,7 +60,7 @@
 #define uss_VolumeLen          300
 #define uss_DirPoolLen         300
 
-#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 extern char *sys_errlist[];
 #endif
 
index 6cd16c0..684ebc7 100644 (file)
@@ -19,6 +19,9 @@
 #include "../afs/sysincludes.h"
 #include "../afs/afsincludes.h"
 #else
+#ifdef __FreeBSD__
+#include <sys/types.h>
+#endif
 #include <netinet/in.h>
 #include <errno.h>
 #include <sys/errno.h>
index 72099d8..dc13a12 100644 (file)
@@ -195,7 +195,7 @@ typedef     struct adaptive_mutex2  adaptive_mutex2_t;
 #include <vfs/vnode.h>
 #include <sys/inode.h>
 #else /* AFS_MACH_ENV */
-#ifdef  AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <ufs/ufs/quota.h> 
@@ -938,7 +938,7 @@ int cnt, size;
 #endif /*AFS_KDUMP_LIB */
 #endif
 
-#ifndef AFS_DARWIN_ENV
+#if !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 int
 findsym( char *sname, off_t *offset )
 {
@@ -1010,7 +1010,7 @@ findsym( char *sname, off_t *offset )
 kdump()
 {
     int cell, cnt, cnt1;
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
    printf("Kdump not supported\n");
 #else
 #ifndef AFS_KDUMP_LIB
@@ -1146,7 +1146,7 @@ kdump()
     return 0;
 }
 
-#ifndef AFS_DARWIN_ENV
+#if !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 int Sum_cellnames=0, Sum_userstp=0, Sum_volnames=0, Sum_exps=0, Sum_nfssysnames=0;
 int Sum_vcachemvids=0, Sum_vcachelinkData=0, Sum_vcacheacc=0, Sum_vcachelocks=0;
 
index 9b0b614..de24918 100644 (file)
@@ -42,7 +42,7 @@
 
 extern char *index ();
 extern char *rindex ();
-#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 extern sys_nerr;
 extern char *sys_errlist[];
 #endif
index 75aadd9..9bfb395 100644 (file)
@@ -74,7 +74,7 @@
 #include <rx/rx.h>
 #include <rx/rx_globals.h>
 #include <sys/stat.h>
-#if ! defined(AFS_SGI_ENV) && ! defined(AFS_AIX32_ENV) && ! defined(AFS_NT40_ENV) && ! defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if ! defined(AFS_SGI_ENV) && ! defined(AFS_AIX32_ENV) && ! defined(AFS_NT40_ENV) && ! defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #include <sys/map.h>
 #endif
 #if !defined(AFS_NT40_ENV)
@@ -85,7 +85,7 @@
 #include <sys/statfs.h>
 #include <sys/lockf.h>
 #else
-#if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #include <sys/dk.h>
 #endif
 #endif
index 328cdd6..7259209 100644 (file)
@@ -92,7 +92,7 @@ listinodes.o: listinodes.c AFS_component_version_number.c
 
 gi: ${DESTDIR}/lib/afs/libsys.a
        case ${SYS_NAME} in \
-                *linux* | sgi_* ) \
+                *linux* | sgi_* | *fbsd* ) \
                        echo "Don't build gi on ${SYS_NAME}";; \
                 *) \
                        ${CC} ${CFLAGS} -c gi.c ; \
index 6e020a1..3af8874 100644 (file)
@@ -21,7 +21,7 @@
 #ifdef AFS_SUN5_ENV
 #include <sys/fs/ufs_fs.h>
 #else
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <ufs/ufs/dinode.h>
 #include <ufs/ffs/fs.h>
 #else
@@ -29,7 +29,7 @@
 #endif
 #endif
 #else /* AFS_VFSINCL_ENV */
-#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX22_ENV)
+#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_FBSD_ENV)
 #include <sys/fs.h>
 #endif
 #endif /* AFS_VFSINCL_ENV */
index 2ba70e7..5222b8c 100644 (file)
@@ -10,6 +10,7 @@
 #ifndef lint
 #endif
 /*
+
        System:         VICE-TWO
        Module:         listinodes.c
        Institution:    The Information Technology Center, Carnegie-Mellon University
@@ -49,7 +50,7 @@ int *forcep, forceR;
 #ifdef   AFS_SUN5_ENV
 #include <sys/fs/ufs_fs.h>
 #else
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <ufs/ufs/dinode.h>
 #include <ufs/ffs/fs.h>
 #define itod ino_to_fsba
@@ -71,7 +72,7 @@ int *forcep, forceR;
 #ifdef   AFS_SUN5_ENV
 #include <sys/fs/ufs_inode.h>
 #else
-#ifndef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV)
 #include <ufs/inode.h>
 #endif
 #endif
@@ -1251,7 +1252,7 @@ int ListViceInodes(devname, mountedOn, resultFile, judgeInode, judgeParam, force
    if (
       (super.fs.fs_magic != FS_MAGIC)
    || (super.fs.fs_ncg < 1)
-#if    defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if    defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
    || (super.fs.fs_cpg < 1)
 #else
    || (super.fs.fs_cpg < 1 || super.fs.fs_cpg > MAXCPG)
index fa8c3c4..ab012fa 100644 (file)
@@ -10,6 +10,7 @@
 #ifndef lint
 #endif
 /*
+
        System:         VICE-TWO
        Module:         partition.c
        Institution:    The Information Technology Center, Carnegie-Mellon University
@@ -29,7 +30,7 @@
 #if AFS_HAVE_STATVFS
 #include <sys/statvfs.h>
 #endif /* AFS_HAVE_STATVFS */
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <sys/mount.h>
 #endif
 
@@ -43,7 +44,7 @@
 #ifdef AFS_SUN5_ENV
 #include <sys/fs/ufs_fs.h>
 #else
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <ufs/ufs/dinode.h>
 #include <ufs/ffs/fs.h>
 #else
@@ -51,7 +52,7 @@
 #endif
 #endif
 #else /* AFS_VFSINCL_ENV */
-#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
 #include <sys/fs.h>
 #endif
 #endif /* AFS_VFSINCL_ENV */
@@ -453,7 +454,7 @@ int VAttachPartitions(void)
 
 }
 #endif
-#if defined(AFS_DUX40_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_DUX40_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 int VAttachPartitions(void)
 {
     int errors = 0;
index eb74b08..5bed33b 100644 (file)
@@ -120,7 +120,7 @@ Vnodes with 0 inode pointers in RW volumes are now deleted.
 #ifdef AFS_SUN5_ENV
 #include <sys/fs/ufs_inode.h>
 #else
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <ufs/ufs/dinode.h>
 #include <ufs/ffs/fs.h>
 #else
@@ -131,7 +131,7 @@ Vnodes with 0 inode pointers in RW volumes are now deleted.
 #ifdef AFS_OSF_ENV
 #include <ufs/inode.h>
 #else  /* AFS_OSF_ENV */
-#ifndef AFS_LINUX20_ENV
+#if !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV)
 #include <sys/inode.h>
 #endif
 #endif
index fc45201..2032ff2 100644 (file)
@@ -33,7 +33,7 @@
 #ifdef AFS_SUN5_ENV
 #include <sys/fs/ufs_fs.h>
 #else
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #include <ufs/ufs/dinode.h>
 #include <ufs/ffs/fs.h>
 #else
@@ -41,7 +41,7 @@
 #endif
 #endif
 #else /* AFS_VFSINCL_ENV */
-#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX20_ENV)
+#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV)
 #include <sys/fs.h>
 #endif
 #endif /* AFS_VFSINCL_ENV */