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};; \
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
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} ;; \
${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} ;; \
MKAFS_OSTYPE=HPUX;; \
*linux*) \
MKAFS_OSTYPE=LINUX;; \
+ *fbsd*) \
+ MKAFS_OSTYPE=FBSD;; \
rs_aix* ) \
MKAFS_OSTYPE=AIX;; \
sgi_* ) \
MKAFS_OSTYPE=HPUX;; \
*linux*) \
MKAFS_OSTYPE=LINUX;; \
+ *fbsd*) \
+ MKAFS_OSTYPE=FBSD;; \
rs_aix* ) \
MKAFS_OSTYPE=AIX;; \
sun4x_5* ) \
--- /dev/null
+#define P1003_1B 1
+#define _KPOSIX_PRIORITY_SCHEDULING 1
--- /dev/null
+/*
+ * 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;
+ }
+}
+
--- /dev/null
+/*
+ * 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);
+}
--- /dev/null
+/*
+ * 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);
+}
--- /dev/null
+/*
+ * 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_ */
--- /dev/null
+/*
+ * 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_ */
--- /dev/null
+/*
+ * 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);
+}
--- /dev/null
+/*
+ * 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);
+}
--- /dev/null
+/*
+ * 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;
+}
--- /dev/null
+/*
+ * 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 */
+}
--- /dev/null
+/*
+ * 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);
+}
+
--- /dev/null
+/*
+ * 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);
+}
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 ;; \
${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 ;; \
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);
#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
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;
* 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 */
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);
#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;
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;
#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)
#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
#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)
#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)
#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 */
}
#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)
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
#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;
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;
-#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
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];
*/
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;
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. */
#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
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. */
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);
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 */
* 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
-#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)
#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 */
#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
#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 */
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;
#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 */
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
) {
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();
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 */
#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)
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)
#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)
stime(&sta);
AFS_GLOCK();
#else
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
AFS_GUNLOCK();
setthetime(atv);
AFS_GLOCK();
#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 */
}
#endif
-#if defined(AFS_DARWIN_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
void afs_osi_TraverseProcTable()
{
struct proc *p;
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;
/*
* 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
* (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)
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(); \
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(); \
if (haveGlock) \
AFS_GLOCK(); \
} while(0)
-#endif /* AFS_OSF_ENV */
+#endif /* AFS_OSF_ENV || AFS_FBSD_ENV */
#else /* AFS_GLOBAL_SUNLOCK */
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 */
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)
#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)
{
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);
#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) */
#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);
* 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
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;
}
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
/* 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);
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
#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) {
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);
#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
#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
#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 )
#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
#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"
# 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
# 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 */
/* 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"
#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
${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
--- /dev/null
+#!/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
#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>
#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
#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
#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
#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);
}
/* 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
/* 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
--- /dev/null
+# 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
#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
--- /dev/null
+#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_ */
--- /dev/null
+#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_ */
#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
#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
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
{
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;
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. */
#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)
{
#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"
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
* 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
}
#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
--- /dev/null
+#/* 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)
${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; \
--- /dev/null
+#/* 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)
#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
#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>
#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>
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; \
#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*/
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
\*******************************************************************/
#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>
#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
--- /dev/null
+/*
+ * 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
+
+
+
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
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.
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 */
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
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();
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();
$(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
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
$(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
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
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)
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();
#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;
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;
--- /dev/null
+/* 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_ */
+
--- /dev/null
+/*
+****************************************************************************
+* 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 = ⊤
+ 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 */
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* ) \
#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.
#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))
/* 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 */
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)))
*/
-#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.
*/
#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)
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
/* 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;
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 ) {
#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)
#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 */
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);
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;
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
#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)
#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.
*/
#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
extern int rxk_initDone;
+#if defined(AFS_FBSD_ENV)
+extern struct domain inetdomain;
+#endif /* AFS_FBSD_ENV */
+
#endif /* _RX_KCOMMON_H_ */
#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 */
#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"
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)
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; \
#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
#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>
#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>
#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 )
{
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
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;
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
#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)
#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
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 ; \
#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
#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 */
#ifndef lint
#endif
/*
+
System: VICE-TWO
Module: listinodes.c
Institution: The Information Technology Center, Carnegie-Mellon University
#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
#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
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)
#ifndef lint
#endif
/*
+
System: VICE-TWO
Module: partition.c
Institution: The Information Technology Center, Carnegie-Mellon University
#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
#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
#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 */
}
#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;
#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
#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
#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
#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 */