From: Tom Maher Date: Sat, 14 Apr 2001 18:27:12 +0000 (+0000) Subject: initial-freebsd-port-work-20010414 X-Git-Tag: openafs-stable-1_1_0~210 X-Git-Url: http://git.openafs.org/?p=openafs.git;a=commitdiff_plain;h=0c1eb3a380a7ec7042167d76faf9193f2e9cd43a initial-freebsd-port-work-20010414 start of work on freebsd port --- diff --git a/src/Makefile b/src/Makefile index fcee729..822cdd6 100644 --- a/src/Makefile +++ b/src/Makefile @@ -202,7 +202,7 @@ null: project gtx: project null auth # kauth rxkad ? case ${SYS_NAME} in \ - rs_aix* | sun4x_5? | sgi_6? | *linux* | ppc_darwin*) \ + rs_aix* | sun4x_5? | sgi_6? | *linux* | ppc_darwin* | *fbsd*) \ rm -f ${DESTDIR}lib/afs/libtermlib.a; \ ln -s libnull.a ${DESTDIR}lib/afs/libtermlib.a; \ ${COMPILE_PART1} gtx ${COMPILE_PART2};; \ @@ -234,7 +234,7 @@ ntp: project volser case ${SYS_NAME} in \ sun4x_58 ) echo skipping ntp for ${SYS_NAME} ;; \ *linux* ) echo skipping ntp for ${SYS_NAME} ;; \ - ppc_darwin* ) echo skipping ntp for ${SYS_NAME} ;; \ + ppc_darwin* | *fbsd* ) echo skipping ntp for ${SYS_NAME} ;; \ * ) ${COMPILE_PART1} ntp ${COMPILE_PART2} ;; \ esac @@ -253,7 +253,7 @@ bozo: project ntp audit vfsck: minproject vol set -x; \ case ${SYS_NAME} in \ - sgi_* | *linux* | rs_aix42 | ppc_darwin* | hp_ux* ) \ + sgi_* | *linux* | rs_aix42 | ppc_darwin* | hp_ux* | *fbsd* ) \ echo skip vfsck for ${SYS_NAME} ;; \ * ) \ ${COMPILE_PART1} vfsck ${COMPILE_PART2} ;; \ @@ -271,7 +271,7 @@ login: project kauth rxkad ${COMPILE_PART1} sia ${COMPILE_PART2} ;; \ sun4x_55 ) \ ${COMPILE_PART1} login ${COMPILE_PART2} ;; \ - sun4x_* | hp_ux11* | *linux* ) \ + sun4x_* | hp_ux11* | *linux* | *fbsd* ) \ ${COMPILE_PART1} pam ${COMPILE_PART2} ;; \ ppc_darwin* ) \ echo Skipping login for ${SYS_NAME} ;; \ @@ -479,6 +479,8 @@ libafs_setup: config minproject export MKAFS_OSTYPE=HPUX;; \ *linux*) \ MKAFS_OSTYPE=LINUX;; \ + *fbsd*) \ + MKAFS_OSTYPE=FBSD;; \ rs_aix* ) \ MKAFS_OSTYPE=AIX;; \ sgi_* ) \ @@ -502,6 +504,8 @@ libuafs_setup: config minproject export MKAFS_OSTYPE=HPUX;; \ *linux*) \ MKAFS_OSTYPE=LINUX;; \ + *fbsd*) \ + MKAFS_OSTYPE=FBSD;; \ rs_aix* ) \ MKAFS_OSTYPE=AIX;; \ sun4x_5* ) \ diff --git a/src/afs/FBSD/opt_posix.h b/src/afs/FBSD/opt_posix.h new file mode 100644 index 0000000..0215c63 --- /dev/null +++ b/src/afs/FBSD/opt_posix.h @@ -0,0 +1,2 @@ +#define P1003_1B 1 +#define _KPOSIX_PRIORITY_SCHEDULING 1 diff --git a/src/afs/FBSD/osi_file.c b/src/afs/FBSD/osi_file.c new file mode 100644 index 0000000..ba711ae --- /dev/null +++ b/src/afs/FBSD/osi_file.c @@ -0,0 +1,234 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + +#include "../afs/param.h" /* Should be always first */ +#include "../afs/sysincludes.h" /* Standard vendor system headers */ +#include "../afs/afsincludes.h" /* Afs-based standard headers */ +#include "../afs/afs_stats.h" /* afs statistics */ + + +int afs_osicred_initialized=0; +struct AFS_UCRED afs_osi_cred; +afs_lock_t afs_xosi; /* lock is for tvattr */ +extern struct osi_dev cacheDev; +extern struct mount *afs_cacheVfsp; + + +void *osi_UFSOpen(ainode) + afs_int32 ainode; +{ + struct inode *ip; + register struct osi_file *afile = NULL; + extern int cacheDiskType; + afs_int32 code = 0; + int dummy; + AFS_STATCNT(osi_UFSOpen); + if(cacheDiskType != AFS_FCACHE_TYPE_UFS) { + osi_Panic("UFSOpen called for non-UFS cache\n"); + } + if (!afs_osicred_initialized) { + /* valid for alpha_osf, SunOS, Ultrix */ + bzero((char *)&afs_osi_cred, sizeof(struct AFS_UCRED)); + afs_osi_cred.cr_ref++; + afs_osicred_initialized = 1; + } + afile = (struct osi_file *) osi_AllocSmallSpace(sizeof(struct osi_file)); + AFS_GUNLOCK(); + code = igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, (ino_t)ainode, &ip, &dummy); + AFS_GLOCK(); + if (code) { + osi_FreeSmallSpace(afile); + osi_Panic("UFSOpen: igetinode failed"); + } + IN_UNLOCK(ip); + afile->vnode = ITOV(ip); + afile->size = VTOI(afile->vnode)->i_size; + afile->offset = 0; + afile->proc = (int (*)()) 0; + afile->inum = ainode; /* for hint validity checking */ + return (void *)afile; +} + +afs_osi_Stat(afile, astat) + register struct osi_file *afile; + register struct osi_stat *astat; { + register afs_int32 code; + struct vattr tvattr; + AFS_STATCNT(osi_Stat); + MObtainWriteLock(&afs_xosi,320); + AFS_GUNLOCK(); + VOP_GETATTR(afile->vnode, &tvattr, &afs_osi_cred, code); + AFS_GLOCK(); + if (code == 0) { + astat->size = tvattr.va_size; + astat->blksize = tvattr.va_blocksize; + astat->mtime = tvattr.va_mtime.tv_sec; + astat->atime = tvattr.va_atime.tv_sec; + } + MReleaseWriteLock(&afs_xosi); + return code; +} + +osi_UFSClose(afile) + register struct osi_file *afile; + { + AFS_STATCNT(osi_Close); + if(afile->vnode) { + AFS_RELE(afile->vnode); + } + + osi_FreeSmallSpace(afile); + return 0; + } + +osi_UFSTruncate(afile, asize) + register struct osi_file *afile; + afs_int32 asize; { + struct AFS_UCRED *oldCred; + struct vattr tvattr; + register afs_int32 code; + struct osi_stat tstat; + AFS_STATCNT(osi_Truncate); + + /* This routine only shrinks files, and most systems + * have very slow truncates, even when the file is already + * small enough. Check now and save some time. + */ + code = afs_osi_Stat(afile, &tstat); + if (code || tstat.size <= asize) return code; + MObtainWriteLock(&afs_xosi,321); + VATTR_NULL(&tvattr); + /* note that this credential swapping stuff is only necessary because + of ufs's references directly to cred instead of to + credentials parameter. Probably should fix ufs some day. */ + oldCred = curproc->p_cred->pc_ucred; /* remember old credentials pointer */ + curproc->p_cred->pc_ucred = &afs_osi_cred; + /* temporarily use superuser credentials */ + tvattr.va_size = asize; + AFS_GUNLOCK(); + VOP_SETATTR(afile->vnode, &tvattr, &afs_osi_cred, code); + AFS_GLOCK(); + curproc->p_cred->pc_ucred = oldCred; /* restore */ + MReleaseWriteLock(&afs_xosi); + return code; +} + +void osi_DisableAtimes(avp) +struct vnode *avp; +{ + struct inode *ip = VTOI(avp); + ip->i_flag &= ~IACC; +} + + +/* Generic read interface */ +afs_osi_Read(afile, offset, aptr, asize) + register struct osi_file *afile; + int offset; + char *aptr; + afs_int32 asize; { + struct AFS_UCRED *oldCred; + unsigned int resid; + register afs_int32 code; + register afs_int32 cnt1=0; + AFS_STATCNT(osi_Read); + + /** + * If the osi_file passed in is NULL, panic only if AFS is not shutting + * down. No point in crashing when we are already shutting down + */ + if ( !afile ) { + if ( !afs_shuttingdown ) + osi_Panic("osi_Read called with null param"); + else + return EIO; + } + + if (offset != -1) afile->offset = offset; + AFS_GUNLOCK(); + code = gop_rdwr(UIO_READ, afile->vnode, (caddr_t) aptr, asize, afile->offset, + AFS_UIOSYS, IO_UNIT, &afs_osi_cred, &resid); + AFS_GLOCK(); + if (code == 0) { + code = asize - resid; + afile->offset += code; + osi_DisableAtimes(afile->vnode); + } + else { + afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, resid, + ICL_TYPE_INT32, code); + code = -1; + } + return code; +} + +/* Generic write interface */ +afs_osi_Write(afile, offset, aptr, asize) + register struct osi_file *afile; + char *aptr; + afs_int32 offset; + afs_int32 asize; { + struct AFS_UCRED *oldCred; + unsigned int resid; + register afs_int32 code; + AFS_STATCNT(osi_Write); + if ( !afile ) + osi_Panic("afs_osi_Write called with null param"); + if (offset != -1) afile->offset = offset; + { + struct ucred *tmpcred = curproc->p_cred->pc_ucred; + curproc->p_cred->pc_ucred = &afs_osi_cred; + AFS_GUNLOCK(); + code = gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize, afile->offset, + AFS_UIOSYS, IO_UNIT, &afs_osi_cred, &resid); + AFS_GLOCK(); + curproc->p_cred->pc_ucred = tmpcred; + } + if (code == 0) { + code = asize - resid; + afile->offset += code; + } + else { + code = -1; + } + if (afile->proc) { + (*afile->proc)(afile, code); + } + return code; +} + + +/* This work should be handled by physstrat in ca/machdep.c. + This routine written from the RT NFS port strategy routine. + It has been generalized a bit, but should still be pretty clear. */ +int afs_osi_MapStrategy(aproc, bp) + int (*aproc)(); + register struct buf *bp; +{ + afs_int32 returnCode; + + AFS_STATCNT(osi_MapStrategy); + returnCode = (*aproc) (bp); + + return returnCode; +} + + + +void +shutdown_osifile() +{ + extern int afs_cold_shutdown; + + AFS_STATCNT(shutdown_osifile); + if (afs_cold_shutdown) { + afs_osicred_initialized = 0; + } +} + diff --git a/src/afs/FBSD/osi_groups.c b/src/afs/FBSD/osi_groups.c new file mode 100644 index 0000000..6e3ef48 --- /dev/null +++ b/src/afs/FBSD/osi_groups.c @@ -0,0 +1,160 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + +/* + * osi_groups.c + * + * Implements: + * Afs_xsetgroups (syscall) + * setpag + * + */ +#include "../afs/param.h" +#include "../afs/sysincludes.h" +#include "../afs/afsincludes.h" +#include "../afs/afs_stats.h" /* statistics */ + +#define NOCRED ((struct ucred *) -1) +#define NOUID ((uid_t) -1) +#define NOGID ((gid_t) -1) + + +static int +afs_getgroups( + struct ucred *cred, + int ngroups, + gid_t *gidset); + +static int +afs_setgroups( + struct proc *proc, + struct ucred **cred, + int ngroups, + gid_t *gidset, + int change_parent); + +int +Afs_xsetgroups(p, args, retval) + struct proc *p; + void *args; + int *retval; +{ + int code = 0; + struct vrequest treq; + + AFS_STATCNT(afs_xsetgroups); + AFS_GLOCK(); + + /* code = afs_InitReq(&treq, u.u_cred); */ + code = afs_InitReq(&treq, curproc->p_cred->pc_ucred); + AFS_GUNLOCK(); + if (code) return code; + + code = setgroups(p, args, retval); + /* Note that if there is a pag already in the new groups we don't + * overwrite it with the old pag. + */ + if (PagInCred(curproc->p_cred->pc_ucred) == NOPAG) { + if (((treq.uid >> 24) & 0xff) == 'A') { + AFS_GLOCK(); + /* we've already done a setpag, so now we redo it */ + AddPag(p, treq.uid, &p->p_rcred); + AFS_GUNLOCK(); + } + } + return code; +} + + +int +setpag(proc, cred, pagvalue, newpag, change_parent) + struct proc *proc; + struct ucred **cred; + afs_uint32 pagvalue; + afs_uint32 *newpag; + afs_uint32 change_parent; +{ + gid_t gidset[NGROUPS]; + int ngroups, code; + int j; + + AFS_STATCNT(setpag); + ngroups = afs_getgroups(*cred, NGROUPS, gidset); + if (afs_get_pag_from_groups(gidset[0], gidset[1]) == NOPAG) { + /* We will have to shift grouplist to make room for pag */ + if (ngroups + 2 > NGROUPS) { + return (E2BIG); + } + for (j = ngroups -1; j >= 0; j--) { + gidset[j+2] = gidset[j]; + } + ngroups += 2; + } + *newpag = (pagvalue == -1 ? genpag(): pagvalue); + afs_get_groups_from_pag(*newpag, &gidset[0], &gidset[1]); + code = afs_setgroups(proc, cred, ngroups, gidset, change_parent); + return code; +} + + +static int +afs_getgroups( + struct ucred *cred, + int ngroups, + gid_t *gidset) +{ + int ngrps, savengrps; + gid_t *gp; + + AFS_STATCNT(afs_getgroups); + savengrps = ngrps = MIN(ngroups, cred->cr_ngroups); + gp = cred->cr_groups; + while (ngrps--) + *gidset++ = *gp++; + return savengrps; +} + + + +static int +afs_setgroups( + struct proc *proc, + struct ucred **cred, + int ngroups, + gid_t *gidset, + int change_parent) +{ + int ngrps; + int i; + gid_t *gp; + struct ucred *newcr, *cr; + + AFS_STATCNT(afs_setgroups); + /* + * The real setgroups() call does this, so maybe we should too. + * + */ + if (ngroups > NGROUPS) + return EINVAL; + cr = *cred; + if (!change_parent) { + crhold(cr); + newcr = crcopy(cr); + } else + newcr = cr; + newcr->cr_ngroups = ngroups; + gp = newcr->cr_groups; + while (ngroups--) + *gp++ = *gidset++; + if (!change_parent) { + substitute_real_creds(proc, NOUID, NOUID, NOGID, NOGID, newcr); + } + *cred = newcr; + return(0); +} diff --git a/src/afs/FBSD/osi_inode.c b/src/afs/FBSD/osi_inode.c new file mode 100644 index 0000000..1c4fc66 --- /dev/null +++ b/src/afs/FBSD/osi_inode.c @@ -0,0 +1,279 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + +/* + * FreeBSD inode operations + * + * Implements: + * + */ +#include "../afs/param.h" /* Should be always first */ +#include "../afs/sysincludes.h" /* Standard vendor system headers */ +#include "../afs/afsincludes.h" /* Afs-based standard headers */ +#include "../afs/osi_inode.h" +#include "../afs/afs_stats.h" /* statistics stuff */ +#include +#include +#include +#include + +getinode(fs, dev, inode, ipp, perror) + struct mount *fs; + struct inode **ipp; + dev_t dev; + ino_t inode; + int *perror; +{ + register struct vnode *vp; + char fake_vnode[FAKE_INODE_SIZE]; + struct inode *ip; + int code; + + *ipp = 0; + *perror = 0; + if (!fs) { + register struct ufsmount *ump; + register struct vnode *vp; + register struct mount *mp; + + MOUNTLIST_LOCK(); + if (mp = TAILQ_FIRST(&mountlist)) do { + /* + * XXX Also do the test for MFS + */ +#undef m_data +#undef m_next + if (mp->mnt_stat.f_type == MOUNT_UFS) { + MOUNTLIST_UNLOCK(); + ump = VFSTOUFS(mp); + if (ump->um_fs == NULL) + break; + if (ump->um_dev == dev) { + fs = ump->um_mountp; + } + MOUNTLIST_LOCK(); + } + mp = TAILQ_NEXT(mp, mnt_list); + } while (mp != TAILQ_FIRST(&mountlist)); + MOUNTLIST_UNLOCK(); + if (!fs) + return(ENXIO); + } + vp = (struct vnode *) fake_vnode; + fake_inode_init(vp, fs); + code = iget(VTOI(vp), inode, &ip, 0); + if (code != 0) { + *perror = BAD_IGET; + return code; + } else { + *ipp = ip; + return(0); + } +} + +igetinode(vfsp, dev, inode, ipp, perror) + struct inode **ipp; + struct mount *vfsp; + dev_t dev; + ino_t inode; + int *perror; +{ + struct inode *pip, *ip; + extern struct osi_dev cacheDev; + register int code = 0; + + *perror = 0; + + AFS_STATCNT(igetinode); + + if ((code = getinode(vfsp, dev, inode, &ip, perror)) != 0) { + return(code); + } + + if (ip->i_mode == 0) { + /* Not an allocated inode */ + iforget(ip); + return(ENOENT); + } + + if (ip->i_nlink == 0 || (ip->i_mode&IFMT) != IFREG) { + iput(ip); + return(ENOENT); + } + + *ipp = ip; + return(0); +} + +iforget(ip) +struct inode *ip; +{ + struct vnode *vp = ITOV(ip); + + AFS_STATCNT(iforget); + + VN_LOCK(vp); + /* this whole thing is too wierd. Why??? XXX */ + if (vp->v_usecount == 1) { + VN_UNLOCK(vp); + idrop(ip); + } else { + VN_UNLOCK(vp); + } +} + +/* + * icreate system call -- create an inode + */ +afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, retval) + long *retval; + long dev, near_inode, param1, param2, param3, param4; +{ + int dummy, err=0; + struct inode *ip, *newip; + register int code; + struct vnode *vp; + + AFS_STATCNT(afs_syscall_icreate); + + if (!afs_suser()) + return(EPERM); + + code = getinode(0, (dev_t)dev, 2, &ip, &dummy); + if (code) { + return(ENOENT); + } + code = ialloc(ip, (ino_t)near_inode, 0, &newip); + iput(ip); + if (code) { + return(code); + } + IN_LOCK(newip); + newip->i_flag |= IACC|IUPD|ICHG; + + newip->i_nlink = 1; + + newip->i_mode = IFREG; + + IN_UNLOCK(newip); + vp = ITOV(newip); + VN_LOCK(vp); + vp->v_type = VREG; + VN_UNLOCK(vp); + + /* + if ( !vp->v_object) + { + extern struct vfs_ubcops ufs_ubcops; + extern struct vm_ubc_object* ubc_object_allocate(); + struct vm_ubc_object* vop; + vop = ubc_object_allocate(&vp, &ufs_ubcops, + vp->v_mount->m_funnel); + VN_LOCK(vp); + vp->v_object = vop; + VN_UNLOCK(vp); + } + */ + + IN_LOCK(newip); + /* newip->i_flags |= IC_XUID|IC_XGID; */ + /* newip->i_flags &= ~IC_PROPLIST; */ + newip->i_vicep1 = param1; + if (param2 == 0x1fffffff/*INODESPECIAL*/) { + newip->i_vicep2 = ((0x1fffffff << 3) + (param4 & 0x3)); + newip->i_vicep3a = (u_short)(param3 >> 16); + newip->i_vicep3b = (u_short)param3; + } else { + newip->i_vicep2 = (((param2 >> 16) & 0x1f) << 27) + + (((param4 >> 16) & 0x1f) << 22) + + (param3 & 0x3fffff); + newip->i_vicep3a = (u_short)param4; + newip->i_vicep3b = (u_short)param2; + } + newip->i_vicemagic = VICEMAGIC; + + *retval = newip->i_number; + IN_UNLOCK(newip); + iput(newip); + return(code); +} + + +afs_syscall_iopen(dev, inode, usrmod, retval) + long *retval; + int dev, inode, usrmod; +{ + struct file *fp; + struct inode *ip; + struct vnode *vp = (struct vnode *)0; + int dummy; + int fd; + extern struct fileops vnops; + register int code; + + AFS_STATCNT(afs_syscall_iopen); + + if (!afs_suser()) + return(EPERM); + + code = igetinode(0, (dev_t)dev, (ino_t)inode, &ip, &dummy); + if (code) { + return(code); + } + if ((code = falloc(curproc, &fp, &fd)) != 0) { + iput(ip); + return(code); + } + IN_UNLOCK(ip); + + /* FreeBSD doesn't do much mp stuff yet :( */ + /* FP_LOCK(fp); */ + fp->f_flag = (usrmod) & FMASK; + fp->f_type = DTYPE_VNODE; + fp->f_ops = &vnops; + fp->f_data = (caddr_t)ITOV(ip); + + /* FP_UNLOCK(fp); */ + return(0); +} + + +/* + * Support for iinc() and idec() system calls--increment or decrement + * count on inode. + * Restricted to super user. + * Only VICEMAGIC type inodes. + */ +afs_syscall_iincdec(dev, inode, inode_p1, amount) + int dev, inode, inode_p1, amount; +{ + int dummy; + struct inode *ip; + register int code; + + if (!afs_suser()) + return(EPERM); + + code = igetinode(0, (dev_t)dev, (ino_t)inode, &ip, &dummy); + if (code) { + return(code); + } + if (!IS_VICEMAGIC(ip)) { + return(EPERM); + } else if (ip->i_vicep1 != inode_p1) { + return(ENXIO); + } + ip->i_nlink += amount; + if (ip->i_nlink == 0) { + CLEAR_VICEMAGIC(ip); + } + ip->i_flag |= ICHG; + iput(ip); + return(0); +} diff --git a/src/afs/FBSD/osi_inode.h b/src/afs/FBSD/osi_inode.h new file mode 100644 index 0000000..39c706f --- /dev/null +++ b/src/afs/FBSD/osi_inode.h @@ -0,0 +1,70 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + +/* + * osi_inode.h + * + * Inode information required for DUX servers and salvager. + */ +#ifndef _OSI_INODE_H_ +#define _OSI_INODE_H_ + +#define BAD_IGET -1000 + +#define VICEMAGIC 0xb61cfa84 + +#define DI_VICEP3(p) \ + ( ((u_int)((p)->di_vicep3a)) << 16 | ((u_int)((p)->di_vicep3b)) ) +#define I_VICE3(p) \ + ( ((u_int)((p)->i_vicep3a)) << 16 | ((u_int)((p)->i_vicep3b)) ) + +#define FAKE_INODE_SIZE (sizeof(struct vnode)+sizeof(struct inode)) +#define MOUNTLIST_UNLOCK() simple_lock_unlock(&mountlist_slock) +#define MOUNTLIST_LOCK() simple_lock(&mountlist_slock) + +/* FreeBSD doesn't actually have a di_proplb, so we use di_spare[0] */ +#define di_proplb di_spare[0] +/* For some reason, they're called "oldids" instead of "bc_{u,g}id" */ +#define di_bcuid di_u.oldids[0] +#define di_bcgid di_u.oldids[1] + +#define i_vicemagic i_din.di_spare[0] +#define i_vicep1 i_din.di_uid +#define i_vicep2 i_din.di_gid +#define i_vicep3a i_din.di_u.oldids[0] +#define i_vicep3b i_din.di_u.oldids[1] +#define i_vicep4 i_din.di_spare[1] /* not used */ + +#define di_vicemagic di_spare[0] +#define di_vicep1 di_uid +#define di_vicep2 di_gid +#define di_vicep3a di_u.oldids[0] +#define di_vicep3b di_u.oldids[1] +#define di_vicep4 di_spare[1] /* not used */ + +/* + * Macros for handling inode numbers: + * inode number to file system block offset. + * inode number to cylinder group number. + * inode number to file system block address. + */ +#define itoo(fs, x) ((x) % INOPB(fs)) +#define itog(fs, x) ((x) / (fs)->fs_ipg) +#define itod(fs, x) \ + ((daddr_t)(cgimin(fs, itog(fs, x)) + \ + (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs)))))) + + +#define IS_VICEMAGIC(ip) ((ip)->i_vicemagic == VICEMAGIC) +#define IS_DVICEMAGIC(dp) ((dp)->di_vicemagic == VICEMAGIC) + +#define CLEAR_VICEMAGIC(ip) (ip)->i_vicemagic = 0 +#define CLEAR_DVICEMAGIC(dp) (dp)->di_vicemagic = 0 + +#endif /* _OSI_INODE_H_ */ diff --git a/src/afs/FBSD/osi_machdep.h b/src/afs/FBSD/osi_machdep.h new file mode 100644 index 0000000..b0c0442 --- /dev/null +++ b/src/afs/FBSD/osi_machdep.h @@ -0,0 +1,91 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + +/* + * + * DUX OSI header file. Extends afs_osi.h. + * + * afs_osi.h includes this file, which is the only way this file should + * be included in a source file. This file can redefine macros declared in + * afs_osi.h. + */ + +#ifndef _OSI_MACHDEP_H_ +#define _OSI_MACHDEP_H_ + +#include +/* #include */ +/* #include */ + +#define getpid() curproc +extern struct simplelock afs_rxglobal_lock; + +/* + * Time related macros + */ +extern struct timeval time; +#define osi_Time() (time.tv_sec) +#define afs_hz hz + +#define PAGESIZE 8192 + +#define AFS_UCRED ucred +#define AFS_PROC struct proc + +#define afs_bufferpages bufpages + +#define osi_vnhold(avc,r) do { \ + if ((avc)->vrefCount) { VN_HOLD((struct vnode *)(avc)); } \ + else osi_Panic("refcnt==0"); } while(0) + +#define gop_rdwr(rw,gp,base,len,offset,segflg,unit,cred,aresid) \ + vn_rdwr((rw),(gp),(base),(len),(offset),(segflg),(unit),(cred),(aresid), curproc) + +#undef afs_suser + +#ifdef KERNEL +extern struct simplelock afs_global_lock; +#if 0 +extern thread_t afs_global_owner; +#define AFS_GLOCK() \ + do { \ + usimple_lock(&afs_global_lock); \ + osi_Assert(afs_global_owner == (thread_t)0); \ + afs_global_owner = current_thread(); \ + } while (0) +#define AFS_GUNLOCK() \ + do { \ + osi_Assert(afs_global_owner == current_thread()); \ + afs_global_owner = (thread_t)0; \ + usimple_unlock(&afs_global_lock); \ + } while(0) +#define ISAFS_GLOCK() (afs_global_owner == current_thread()) +#else +#define AFS_GLOCK() \ + do { \ + simple_lock(&afs_global_lock); \ + } while (0) +#define AFS_GUNLOCK() \ + do { \ + simple_unlock(&afs_global_lock); \ + } while(0) +#endif /* 0 */ +#define AFS_RXGLOCK() +#define AFS_RXGUNLOCK() +#define ISAFS_RXGLOCK() 1 + +#undef SPLVAR +#define SPLVAR +#undef NETPRI +#define NETPRI +#undef USERPRI +#define USERPRI +#endif /* KERNEL */ + +#endif /* _OSI_MACHDEP_H_ */ diff --git a/src/afs/FBSD/osi_misc.c b/src/afs/FBSD/osi_misc.c new file mode 100644 index 0000000..00d91cf --- /dev/null +++ b/src/afs/FBSD/osi_misc.c @@ -0,0 +1,34 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + +/* + * osi_misc.c + * + * Implements: + * afs_suser + */ + +#include "../afs/param.h" /* Should be always first */ +#include "../afs/sysincludes.h" /* Standard vendor system headers */ +#include "../afs/afsincludes.h" /* Afs-based standard headers */ + +/* + * afs_suser() returns true if the caller is superuser, false otherwise. + * + * Note that it must NOT set errno. + */ + +afs_suser() { + int error; + + if (suser(curproc) == 0) { + return(1); + } + return(0); +} diff --git a/src/afs/FBSD/osi_sleep.c b/src/afs/FBSD/osi_sleep.c new file mode 100644 index 0000000..84bd0be --- /dev/null +++ b/src/afs/FBSD/osi_sleep.c @@ -0,0 +1,184 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + + +#include "../afs/param.h" /* Should be always first */ +#include "../afs/sysincludes.h" /* Standard vendor system headers */ +#include "../afs/afsincludes.h" /* Afs-based standard headers */ +#include "../afs/afs_stats.h" /* afs statistics */ + + + +static int osi_TimedSleep(char *event, afs_int32 ams, int aintok); +void afs_osi_Wakeup(char *event); +void afs_osi_Sleep(char *event); + +static char waitV; + + +void afs_osi_InitWaitHandle(struct afs_osi_WaitHandle *achandle) +{ + AFS_STATCNT(osi_InitWaitHandle); + achandle->proc = (caddr_t) 0; +} + +/* cancel osi_Wait */ +void afs_osi_CancelWait(struct afs_osi_WaitHandle *achandle) +{ + caddr_t proc; + + AFS_STATCNT(osi_CancelWait); + proc = achandle->proc; + if (proc == 0) return; + achandle->proc = (caddr_t) 0; /* so dude can figure out he was signalled */ + afs_osi_Wakeup(&waitV); +} + +/* afs_osi_Wait + * Waits for data on ahandle, or ams ms later. ahandle may be null. + * Returns 0 if timeout and EINTR if signalled. + */ +int afs_osi_Wait(afs_int32 ams, struct afs_osi_WaitHandle *ahandle, int aintok) +{ + int code; + afs_int32 endTime, tid; + + AFS_STATCNT(osi_Wait); + endTime = osi_Time() + (ams/1000); + if (ahandle) + ahandle->proc = (caddr_t) curproc; + do { + AFS_ASSERT_GLOCK(); + code = 0; + code = osi_TimedSleep(&waitV, ams, aintok); + + if (code) break; /* if something happened, quit now */ + /* if we we're cancelled, quit now */ + if (ahandle && (ahandle->proc == (caddr_t) 0)) { + /* we've been signalled */ + break; + } + } while (osi_Time() < endTime); + return code; +} + + + + +typedef struct afs_event { + struct afs_event *next; /* next in hash chain */ + char *event; /* lwp event: an address */ + int refcount; /* Is it in use? */ + int seq; /* Sequence number: this is incremented + by wakeup calls; wait will not return until + it changes */ + int cond; +} afs_event_t; + +#define HASHSIZE 128 +afs_event_t *afs_evhasht[HASHSIZE];/* Hash table for events */ +#define afs_evhash(event) (afs_uint32) ((((long)event)>>2) & (HASHSIZE-1)); +int afs_evhashcnt = 0; + +/* Get and initialize event structure corresponding to lwp event (i.e. address) + * */ +static afs_event_t *afs_getevent(char *event) +{ + afs_event_t *evp, *newp = 0; + int hashcode; + + AFS_ASSERT_GLOCK(); + hashcode = afs_evhash(event); + evp = afs_evhasht[hashcode]; + while (evp) { + if (evp->event == event) { + evp->refcount++; + return evp; + } + if (evp->refcount == 0) + newp = evp; + evp = evp->next; + } + if (!newp) { + newp = (afs_event_t *) osi_AllocSmallSpace(sizeof (afs_event_t)); + afs_evhashcnt++; + newp->next = afs_evhasht[hashcode]; + afs_evhasht[hashcode] = newp; + newp->seq = 0; + } + newp->event = event; + newp->refcount = 1; + return newp; +} + +/* Release the specified event */ +#define relevent(evp) ((evp)->refcount--) + + +void afs_osi_Sleep(char *event) +{ + struct afs_event *evp; + int seq; + + evp = afs_getevent(event); + seq = evp->seq; + while (seq == evp->seq) { + AFS_ASSERT_GLOCK(); + assert_wait((vm_offset_t)(&evp->cond), 0); + AFS_GUNLOCK(); + thread_block(); + AFS_GLOCK(); + } + relevent(evp); +} + +/* osi_TimedSleep + * + * Arguments: + * event - event to sleep on + * ams --- max sleep time in milliseconds + * aintok - 1 if should sleep interruptibly + * + * Returns 0 if timeout and EINTR if signalled. + */ +static int osi_TimedSleep(char *event, afs_int32 ams, int aintok) +{ + int code = 0; + struct afs_event *evp; + int ticks; + + ticks = ( ams * afs_hz )/1000; + + + evp = afs_getevent(event); + + assert_wait((vm_offset_t)(&evp->cond), aintok); + AFS_GUNLOCK(); + thread_set_timeout(ticks); + thread_block(); + AFS_GLOCK(); + /* if (current_thread()->wait_result != THREAD_AWAKENED) + code = EINTR; */ + + relevent(evp); + return code; +} + + +void afs_osi_Wakeup(char *event) +{ + struct afs_event *evp; + + evp = afs_getevent(event); + if (evp->refcount > 1) { + evp->seq++; + thread_wakeup((vm_offset_t)(&evp->cond)); + } + relevent(evp); +} diff --git a/src/afs/FBSD/osi_vfsops.c b/src/afs/FBSD/osi_vfsops.c new file mode 100644 index 0000000..a87c70b --- /dev/null +++ b/src/afs/FBSD/osi_vfsops.c @@ -0,0 +1,481 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + +/* + * osi_vfsops.c for DUX + */ +#include "../afs/param.h" /* Should be always first */ +#include "../afs/sysincludes.h" /* Standard vendor system headers */ +#include "../afs/afsincludes.h" /* Afs-based standard headers */ +#include "../afs/afs_stats.h" /* statistics stuff */ +#include +#include +#include +#include +#include +#include +#include +#include + + +struct vcache *afs_globalVp = 0; +struct mount *afs_globalVFS = 0; + +static u_char afs_mntid; +int afs_vfsdev = 0; +udecl_simple_lock_data(, afsmntid_lock) +#define AFSMNTID_LOCK() usimple_lock(&afsmntid_lock) +#define AFSMNTID_UNLOCK() usimple_unlock(&afsmntid_lock) +#define AFSMNTID_LOCK_INIT() usimple_lock_init(&afsmntid_lock) + + +int mp_afs_mount(struct mount *afsp,char * path, caddr_t data, + struct nameidata *ndp) +{ + u_int size; + + fsid_t tfsid; + struct mount *xmp, *getvfs(); + int code; + + AFS_GLOCK(); + AFS_STATCNT(afs_mount); + + if (afs_globalVFS) { /* Don't allow remounts. */ + AFS_GUNLOCK(); + return (EBUSY); + } + + afs_globalVFS = afsp; + afsp->vfs_bsize = 8192; +/* + * Generate a unique afs mount i.d. ( see nfs_mount() ). + */ + afsp->m_stat.f_fsid.val[0] = makedev(130, 0); + afsp->m_stat.f_fsid.val[1] = MOUNT_AFS; + AFSMNTID_LOCK(); + if (++afs_mntid == 0) + ++afs_mntid; + AFSMNTID_UNLOCK(); + BM(AFSMNTID_LOCK()); + tfsid.val[0] = makedev(130, afs_mntid); + tfsid.val[1] = MOUNT_AFS; + BM(AFSMNTID_UNLOCK()); + + while (xmp = getvfs(&tfsid)) { + UNMOUNT_READ_UNLOCK(xmp); + tfsid.val[0]++; + AFSMNTID_LOCK(); + afs_mntid++; + AFSMNTID_UNLOCK(); + } + if (major(tfsid.val[0]) != 130) { + AFS_GUNLOCK(); + return (ENOENT); + } + afsp->m_stat.f_fsid.val[0] = tfsid.val[0]; + + afsp->m_stat.f_mntonname = AFS_KALLOC(MNAMELEN); + afsp->m_stat.f_mntfromname = AFS_KALLOC(MNAMELEN); + if ( !afsp->m_stat.f_mntonname || !afsp->m_stat.f_mntfromname) + panic("malloc failure in afs_mount\n"); + + bzero(afsp->m_stat.f_mntonname, MNAMELEN); + bzero(afsp->m_stat.f_mntfromname, MNAMELEN); + AFS_COPYINSTR(path, (caddr_t)afsp->m_stat.f_mntonname, MNAMELEN, &size, code); + bcopy("AFS", afsp->m_stat.f_mntfromname, 4); + AFS_GUNLOCK(); + (void) mp_afs_statfs(afsp); + AFS_GLOCK(); + afs_vfsdev = afsp->m_stat.f_fsid.val[0]; + +#ifndef AFS_NONFSTRANS + /* Set up the xlator in case it wasn't done elsewhere */ + afs_xlatorinit_v2(); + afs_xlatorinit_v3(); +#endif + AFS_GUNLOCK(); + return 0; +} + + +int mp_afs_unmount (struct mount *afsp, int flag) +{ + AFS_GLOCK(); + AFS_STATCNT(afs_unmount); + afs_globalVFS = 0; + afs_shutdown(); + AFS_GUNLOCK(); + return 0; +} + + +int mp_afs_start(struct mount *mp, int flags) +{ + return(0); +} + +int mp_afs_root (struct mount *afsp, struct vnode **avpp) +{ + register afs_int32 code = 0; + struct vrequest treq; + register struct vcache *tvp=0; + + AFS_GLOCK(); + AFS_STATCNT(afs_root); + if (afs_globalVp && (afs_globalVp->states & CStatd)) { + tvp = afs_globalVp; + } else { + if (!(code = afs_InitReq(&treq, cred)) && + !(code = afs_CheckInit())) { + tvp = afs_GetVCache(&afs_rootFid, &treq, (afs_int32 *)0, + (struct vcache*)0, WRITE_LOCK); + /* we really want this to stay around */ + if (tvp) { + afs_globalVp = tvp; + } else + code = ENOENT; + } + } + if (tvp) { + AFS_GUNLOCK(); + VN_HOLD((struct vnode *)tvp); + VN_LOCK((struct vnode *)tvp); + tvp->v.v_flag |= VROOT; /* No-op on Ultrix 2.2 */ + VN_UNLOCK((struct vnode *)tvp); + AFS_GLOCK(); + + afs_globalVFS = afsp; + *avpp = (struct vnode *) tvp; + } + + afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *avpp, + ICL_TYPE_INT32, code); + AFS_GUNLOCK(); + return code; +} + + +mp_afs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg) +{ + return EOPNOTSUPP; +} + +int mp_afs_statfs(struct mount *afsp) +{ + struct nstatfs *abp = &afsp->m_stat; + + AFS_GLOCK(); + AFS_STATCNT(afs_statfs); + + abp->f_type = MOUNT_AFS; + abp->f_bsize = afsp->vfs_bsize; + + /* Fake a high number below to satisfy programs that use the statfs call + * to make sure that there's enough space in the device partition before + * storing something there. + */ + abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files = + abp->f_ffree = 2000000; + abp->f_fsize = 1024; + + abp->f_fsid.val[0] = afsp->m_stat.f_fsid.val[0]; + abp->f_fsid.val[1] = afsp->m_stat.f_fsid.val[1]; + + AFS_GUNLOCK(); + return 0; +} + + +int mp_afs_sync(struct mount *mp, int flags) +{ + AFS_STATCNT(afs_sync); + return 0; +} + + +int mp_afs_fhtovp(struct mount *afsp, struct fid *fidp, struct vnode **avcp) +{ + struct vrequest treq; + register code = 0; + + AFS_GLOCK(); + AFS_STATCNT(afs_vget); + + *avcp = NULL; + + if ((code = afs_InitReq(&treq, cred)) == 0) { + code = afs_osi_vget((struct vcache**)avcp, fidp, &treq); + } + + afs_Trace3(afs_iclSetp, CM_TRACE_VGET, ICL_TYPE_POINTER, *avcp, + ICL_TYPE_INT32, treq.uid, ICL_TYPE_FID, fidp); + + code = afs_CheckCode(code, &treq, 42); + AFS_GUNLOCK(); + return code; +} + + +/* + * afs_vptofh + * + * afs_vptofh can return two flavors of NFS fid, depending on if submounts are + * allowed. The reason for this is that we can't guarantee that we found all + * the entry points any OS might use to get the fid for the NFS mountd. + * Hence we return a "magic" fid for all but /afs. If it goes through the + * translator code, it will get transformed into a SmallFid that we recognize. + * So, if submounts are disallowed, and an NFS client tries a submount, it will + * get a fid which we don't recognize and the mount will either fail or we + * will ignore subsequent requests for that mount. + * + * The Alpha fid is organized differently than for other platforms. Their + * intention was to have the data portion of the fid aligned on a 4 byte + * boundary. To do so, the fid is organized as: + * u_short reserved + * u_short len + * char data[8] + * The len field is the length of the entire fid, from reserved through data. + * This length is used by fid_copy to include copying the reserved field. + * Alpha's zero the reserved field before handing us the fid, but they use + * it in fid_cmp. We use the reserved field to store the 16 bits of the Vnode. + * + * Note that the SmallFid only allows for 8 bits of the cell index and + * 16 bits of the vnode. + */ + +#define AFS_FIDDATASIZE 8 +#define AFS_SIZEOFSMALLFID 12 /* full size of fid, including len field */ +extern int afs_NFSRootOnly; /* 1 => only allow NFS mounts of /afs. */ +int afs_fid_vnodeoverflow=0, afs_fid_uniqueoverflow=0; + +int mp_afs_vptofh(struct vnode *avn, struct fid *fidp) +{ + struct SmallFid Sfid; + long addr[2]; + register struct cell *tcell; + int rootvp = 0; + struct vcache *avc = (struct vcache *)avn; + + AFS_GLOCK(); + AFS_STATCNT(afs_fid); + + if (afs_shuttingdown) { + AFS_GUNLOCK(); + return EIO; + } + + if (afs_NFSRootOnly && (avc == afs_globalVp)) rootvp = 1; + if (!afs_NFSRootOnly || rootvp) { + tcell = afs_GetCell(avc->fid.Cell, READ_LOCK); + Sfid.Volume = avc->fid.Fid.Volume; + fidp->fid_reserved = avc->fid.Fid.Vnode; + Sfid.CellAndUnique = ((tcell->cellIndex << 24) + + (avc->fid.Fid.Unique & 0xffffff)); + afs_PutCell(tcell, READ_LOCK); + if (avc->fid.Fid.Vnode > 0xffff) + afs_fid_vnodeoverflow++; + if (avc->fid.Fid.Unique > 0xffffff) + afs_fid_uniqueoverflow++; + } else { + fidp->fid_reserved = AFS_XLATOR_MAGIC; + addr[0] = (long)avc; + AFS_GUNLOCK(); + VN_HOLD((struct vnode *)avc); + AFS_GLOCK(); + } + + /* Use the fid pointer passed to us. */ + fidp->fid_len = AFS_SIZEOFSMALLFID; + if (afs_NFSRootOnly) { + if (rootvp) { + bcopy((caddr_t)&Sfid, fidp->fid_data, AFS_FIDDATASIZE); + } else { + bcopy((caddr_t)addr, fidp->fid_data, AFS_FIDDATASIZE); + } + } else { + bcopy((caddr_t)&Sfid, fidp->fid_data, AFS_FIDDATASIZE); + } + AFS_GUNLOCK(); + return 0; +} + + +int mp_Afs_init(void); /* vfs_init - defined below */ + + +/* This is only called by vfs_mount when afs is going to be mounted as root. + * Since we don't support diskless clients we shouldn't come here. + */ +int afsmountroot=0; +int mp_afs_mountroot(struct mount *afsp, struct vnode **vp) +{ + AFS_GLOCK(); + AFS_STATCNT(afs_mountroot); + afsmountroot++; + AFS_GUNLOCK(); + return EINVAL; +} + + +/* It's called to setup swapping over the net for diskless clients; again + * not for us. + */ +int afsswapvp=0; +int mp_afs_swapvp(void) +{ + AFS_GLOCK(); + AFS_STATCNT(afs_swapvp); + afsswapvp++; + AFS_GUNLOCK(); + return EINVAL; +} + + +struct vfsops afs_vfsops = { + mp_afs_mount, + mp_afs_start, + mp_afs_unmount, + mp_afs_root, + mp_afs_quotactl, + mp_afs_statfs, + mp_afs_sync, + mp_afs_fhtovp, /* afs_vget */ + mp_afs_vptofh, + mp_Afs_init, + mp_afs_mountroot, + mp_afs_swapvp +}; + + +/* + * System Call Entry Points + */ +#define NULL_FUNC (int (*)(int))0 + +int (*afs_syscall_func)() = NULL_FUNC; +int (*afs_xsetgroups_func)() = NULL_FUNC; +int (*afs_xioctl_func)() = NULL_FUNC; + +afssyscall(p, args, retval) + struct proc *p; + void *args; + long *retval; +{ + int (*func)(); + int code; + + AFS_GLOCK(); + func = afs_syscall_func; + if (func == NULL_FUNC) { + code = nosys(p, args, retval); + } else { + code = (*func)(p, args, retval); + } + AFS_GUNLOCK(); + return code; +} + +afsxsetgroups(p, args, retval) + struct proc *p; + void *args; + long *retval; +{ + int (*func)(); + int code; + + AFS_GLOCK(); + func = afs_xsetgroups_func; + if (func == NULL_FUNC) { + code = nosys(p, args, retval); + } else { + code = (*func)(p, args, retval); + } + AFS_GUNLOCK(); + return code; +} + +afsxioctl(p, args, retval) + struct proc *p; + void *args; + long *retval; +{ + int (*func)(); + int code; + + AFS_GLOCK(); + func = afs_xioctl_func; + if (func == NULL_FUNC) { + code = nosys(p, args, retval); + } else { + code = (*func)(p, args, retval); + } + AFS_GUNLOCK(); + return code; +} + + +/* + * VFS initialization and unload + */ + +afs_unconfig() +{ + return EBUSY; +} + + +cfg_subsys_attr_t afs_attributes[] = { + {"", 0, 0, 0, 0, 0, 0} /* must be the last element */ +}; + +afs_configure(cfg_op_t op, caddr_t indata, size_t indata_size, caddr_t outdata, size_t outdata_size) +{ + cfg_attr_t *attributes; + int ret = ESUCCESS; + int i, j, size; + caddr_t p; + + switch (op) { + case CFG_OP_CONFIGURE: + /* + * The indata parameter is a list of attributes to be configured, and + * indata_size is the count of attributes. + */ + if ((ret = vfssw_add_fsname(MOUNT_AFS, &afs_vfsops, "afs")) != 0) + return(ret); + break; + case CFG_OP_UNCONFIGURE: + if ((ret = afs_unconfig()) != 0) + return(ret); + break; + default: + ret = EINVAL; + break; + } + return ret; +} + + +int mp_Afs_init(void) +{ + extern int Afs_xsetgroups(), afs_xioctl(), afs3_syscall(); + + AFS_GLOCK(); + sysent[AFS_SYSCALL].sy_call = afs3_syscall; + sysent[AFS_SYSCALL].sy_parallel = 0; + sysent[AFS_SYSCALL].sy_narg = 6; + sysent[SYS_setgroups].sy_call = Afs_xsetgroups; + afs_xioctl_func = afsxioctl; + afs_xsetgroups_func = afsxsetgroups; + afs_syscall_func = afssyscall; + AFS_GUNLOCK(); + + return 0; +} diff --git a/src/afs/FBSD/osi_vm.c b/src/afs/FBSD/osi_vm.c new file mode 100644 index 0000000..6d29231 --- /dev/null +++ b/src/afs/FBSD/osi_vm.c @@ -0,0 +1,210 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + + +/* osi_vm.c implements: + * + * osi_VM_FlushVCache(avc, slept) + * osi_ubc_flush_dirty_and_wait(vp, flags) + * osi_VM_StoreAllSegments(avc) + * osi_VM_TryToSmush(avc, acred, sync) + * osi_VM_FlushPages(avc, credp) + * osi_VM_Truncate(avc, alen, acred) + */ + +#include "../afs/param.h" /* Should be always first */ +#include "../afs/sysincludes.h" /* Standard vendor system headers */ +#include "../afs/afsincludes.h" /* Afs-based standard headers */ +#include "../afs/afs_stats.h" /* statistics */ +/* #include */ +#include +#include + +/* Try to discard pages, in order to recycle a vcache entry. + * + * We also make some sanity checks: ref count, open count, held locks. + * + * We also do some non-VM-related chores, such as releasing the cred pointer + * (for AIX and Solaris) and releasing the gnode (for AIX). + * + * Locking: afs_xvcache lock is held. If it is dropped and re-acquired, + * *slept should be set to warn the caller. + * + * Formerly, afs_xvcache was dropped and re-acquired for Solaris, but now it + * is not dropped and re-acquired for any platform. It may be that *slept is + * therefore obsolescent. + * + * OSF/1 Locking: VN_LOCK has been called. + */ +int +osi_VM_FlushVCache(avc, slept) + struct vcache *avc; + int *slept; +{ +#ifdef SECRETLY_OSF1 + if (avc->vrefCount > 1) + return EBUSY; + + if (avc->opens) + return EBUSY; + + /* if a lock is held, give up */ + if (CheckLock(&avc->lock) || afs_CheckBozonLock(&avc->pvnLock)) + return EBUSY; + + AFS_GUNLOCK(); + ubc_invalidate(((struct vnode *)avc)->v_object, 0, 0, B_INVAL); + AFS_GLOCK(); +#endif /* SECRETLY_OSF1 */ + + return 0; +} + +/* + * osi_ubc_flush_dirty_and_wait -- ensure all dirty pages cleaned + * + * Alpha OSF/1 doesn't make it easy to wait for all dirty pages to be cleaned. + * NFS tries to do this by calling waitforio(), which waits for v_numoutput + * to go to zero. But that isn't good enough, because afs_putpage() doesn't + * increment v_numoutput until it has obtained the vcache entry lock. Suppose + * that Process A, trying to flush a page, is waiting for that lock, and + * Process B tries to close the file. Process B calls waitforio() which thinks + * that everything is cool because v_numoutput is still zero. Process B then + * proceeds to call afs_StoreAllSegments(). Finally when B is finished, A gets + * to proceed and flush its page. But then it's too late because the file is + * already closed. + * + * (I suspect that waitforio() is not adequate for NFS, just as it isn't + * adequate for us. But that's not my problem.) + * + * The only way we can be sure that there are no more dirty pages is if there + * are no more pages with pg_busy set. We look for them on the cleanpl. + * + * For some reason, ubc_flush_dirty() only looks at the dirtypl, not the + * dirtywpl. I don't know why this is good enough, but I assume it is. By + * the same token, I only look for busy pages on the cleanpl, not the cleanwpl. + * + * Called with the global lock NOT held. + */ +void +osi_ubc_flush_dirty_and_wait(vp, flags) +struct vnode *vp; +int flags; { + int retry; + vm_page_t pp; + int first; + +#ifdef SECRETLY_OSF1 + do { + struct vm_ubc_object* vop; + vop = (struct vm_ubc_object*)(vp->v_object); + ubc_flush_dirty(vop, flags); + + vm_object_lock(vop); + if (vop->vu_dirtypl) + /* shouldn't happen, but who knows */ + retry = 1; + else { + retry = 0; + if (vop->vu_cleanpl) { + for (first = 1, pp = vop->vu_cleanpl; + first || pp != vop->vu_cleanpl; + first = 0, pp = pp->pg_onext) { + if (pp->pg_busy) { + retry = 1; + pp->pg_wait = 1; + assert_wait_mesg((vm_offset_t)pp, FALSE, "pg_wait"); + vm_object_unlock(vop); + thread_block(); + break; + } + } + } + if (retry) continue; + } + vm_object_unlock(vop); + } while (retry); +#endif /* SECRETLY_OSF1 */ +} + +/* Try to store pages to cache, in order to store a file back to the server. + * + * Locking: the vcache entry's lock is held. It will usually be dropped and + * re-obtained. + */ +void +osi_VM_StoreAllSegments(avc) + struct vcache *avc; +{ +#ifdef SECRETLY_OSF1 + ReleaseWriteLock(&avc->lock); + AFS_GUNLOCK(); + osi_ubc_flush_dirty_and_wait((struct vnode *)avc, 0); + AFS_GLOCK(); + ObtainWriteLock(&avc->lock,94); +#endif /* SECRETLY_OSF1 */ +} + +/* Try to invalidate pages, for "fs flush" or "fs flushv"; or + * try to free pages, when deleting a file. + * + * Locking: the vcache entry's lock is held. It may be dropped and + * re-obtained. + * + * Since we drop and re-obtain the lock, we can't guarantee that there won't + * be some pages around when we return, newly created by concurrent activity. + */ +void +osi_VM_TryToSmush(avc, acred, sync) + struct vcache *avc; + struct AFS_UCRED *acred; + int sync; +{ +#ifdef SECRETLY_OSF1 + ReleaseWriteLock(&avc->lock); + AFS_GUNLOCK(); + osi_ubc_flush_dirty_and_wait((struct vnode *)avc, 0); + ubc_invalidate(((struct vnode *)avc)->v_object, 0, 0, B_INVAL); + AFS_GLOCK(); + ObtainWriteLock(&avc->lock,59); +#endif /* SECRETLY_OSF1 */ +} + +/* Purge VM for a file when its callback is revoked. + * + * Locking: No lock is held, not even the global lock. + */ +void +osi_VM_FlushPages(avc, credp) + struct vcache *avc; + struct AFS_UCRED *credp; +{ +#ifdef SECRETLY_OSF1 + ubc_flush_dirty(((struct vnode *)avc)->v_object, 0); + ubc_invalidate(((struct vnode *)avc)->v_object, 0, 0, B_INVAL); +#endif /* SECRETLY_OSF1 */ +} + +/* Purge pages beyond end-of-file, when truncating a file. + * + * Locking: no lock is held, not even the global lock. + * activeV is raised. This is supposed to block pageins, but at present + * it only works on Solaris. + */ +void +osi_VM_Truncate(avc, alen, acred) + struct vcache *avc; + int alen; + struct AFS_UCRED *acred; +{ +#ifdef SECRETLY_OSF1 + ubc_invalidate(((struct vnode *)avc)->v_object, alen, + MAXINT - alen, B_INVAL); +#endif /* SECRETLY_OSF1 */ +} diff --git a/src/afs/FBSD/osi_vnodeops.c b/src/afs/FBSD/osi_vnodeops.c new file mode 100644 index 0000000..617d6a0 --- /dev/null +++ b/src/afs/FBSD/osi_vnodeops.c @@ -0,0 +1,1091 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + +/* + * vnodeops structure and Digital Unix specific ops and support routines. + */ + +#include "../afs/param.h" /* Should be always first */ + +#include "../afs/sysincludes.h" /* Standard vendor system headers */ +#include "../afs/afsincludes.h" /* Afs-based standard headers */ +#include "../afs/afs_stats.h" /* statistics */ +#include +#include +#include +/* #include */ +#include "../afs/afs_cbqueue.h" +#include "../afs/nfsclient.h" +#include "../afs/afs_osidnlc.h" + + +extern int afs_lookup(), afs_create(), afs_noop(), afs_open(), afs_close(); +extern int afs_access(), afs_getattr(), afs_setattr(), afs_badop(); +extern int afs_fsync(), afs_seek(), afs_remove(), afs_link(), afs_rename(); +extern int afs_mkdir(), afs_rmdir(), afs_symlink(), afs_readdir(); +extern int afs_readlink(), afs_lockctl(); +extern int vn_pathconf_default(), seltrue(); + +int mp_afs_lookup(), mp_afs_create(), mp_afs_open(); +int mp_afs_access(), mp_afs_getattr(), mp_afs_setattr(), mp_afs_ubcrdwr(); +int mp_afs_ubcrdwr(), mp_afs_mmap(); +int mp_afs_fsync(), mp_afs_seek(), mp_afs_remove(), mp_afs_link(); +int mp_afs_rename(), mp_afs_mkdir(), mp_afs_rmdir(), mp_afs_symlink(); +int mp_afs_readdir(), mp_afs_readlink(), mp_afs_abortop(), mp_afs_inactive(); +int mp_afs_reclaim(), mp_afs_bmap(), mp_afs_strategy(), mp_afs_print(); +int mp_afs_page_read(), mp_afs_page_write(), mp_afs_swap(), mp_afs_bread(); +int mp_afs_brelse(), mp_afs_lockctl(), mp_afs_syncdata(), mp_afs_close(); +int mp_afs_closex(); + +#if 0 +/* AFS vnodeops */ +struct vnodeops Afs_vnodeops = { + mp_afs_lookup, + mp_afs_create, + afs_noop, /* vn_mknod */ + mp_afs_open, + mp_afs_close, + mp_afs_access, + mp_afs_getattr, + mp_afs_setattr, + mp_afs_ubcrdwr, + mp_afs_ubcrdwr, + afs_badop, /* vn_ioctl */ + seltrue, /* vn_select */ + mp_afs_mmap, + mp_afs_fsync, + mp_afs_seek, + mp_afs_remove, + mp_afs_link, + mp_afs_rename, + mp_afs_mkdir, + mp_afs_rmdir, + mp_afs_symlink, + mp_afs_readdir, + mp_afs_readlink, + mp_afs_abortop, + mp_afs_inactive, + mp_afs_reclaim, + mp_afs_bmap, + mp_afs_strategy, + mp_afs_print, + mp_afs_page_read, + mp_afs_page_write, + mp_afs_swap, + mp_afs_bread, + mp_afs_brelse, + mp_afs_lockctl, + mp_afs_syncdata, + afs_noop, /* Lock */ + afs_noop, /* unLock */ + afs_noop, /* get ext attrs */ + afs_noop, /* set ext attrs */ + afs_noop, /* del ext attrs */ + vn_pathconf_default, +}; +struct vnodeops *afs_ops = &Afs_vnodeops; +#endif /* 0 */ + +/* vnode file operations, and our own */ +extern int vn_read(); +extern int vn_write(); +extern int vn_ioctl(); +extern int vn_select(); +extern int afs_closex(); + +struct fileops afs_fileops = { + vn_read, + vn_write, + vn_ioctl, + vn_select, + mp_afs_closex, +}; + +#if 0 +mp_afs_lookup(adp, ndp) + struct vcache *adp; + struct nameidata *ndp; +{ + int code; + AFS_GLOCK(); + code = afs_lookup(adp, ndp); + AFS_GUNLOCK(); + return code; +} + +mp_afs_create(ndp, attrs) + struct nameidata *ndp; + struct vattr *attrs; +{ + int code; + AFS_GLOCK(); + code = afs_create(ndp, attrs); + AFS_GUNLOCK(); + return code; +} + +mp_afs_open(avcp, aflags, acred) + struct vcache **avcp; + afs_int32 aflags; + struct AFS_UCRED *acred; +{ + int code; + AFS_GLOCK(); + code = afs_open(avcp, aflags, acred); + AFS_GUNLOCK(); + return code; +} + +mp_afs_access(avc, amode, acred) + struct vcache *avc; + afs_int32 amode; + struct AFS_UCRED *acred; +{ + int code; + AFS_GLOCK(); + code = afs_access(avc, amode, acred); + AFS_GUNLOCK(); + return code; +} + +mp_afs_close(avc, flags, cred) + struct vnode *avc; + int flags; + struct ucred *cred; +{ + int code; + AFS_GLOCK(); + code = afs_close(avc, flags, cred); + AFS_GUNLOCK(); + return code; +} + +mp_afs_getattr(avc, attrs, acred) + struct vcache *avc; + struct vattr *attrs; + struct AFS_UCRED *acred; +{ + int code; + AFS_GLOCK(); + code = afs_getattr(avc, attrs, acred); + AFS_GUNLOCK(); + return code; +} + +mp_afs_setattr(avc, attrs, acred) + struct vcache *avc; + struct vattr *attrs; + struct AFS_UCRED *acred; +{ + int code; + AFS_GLOCK(); + code = afs_setattr(avc, attrs, acred); + AFS_GUNLOCK(); + return code; +} + +mp_afs_fsync(avc, fflags, acred, waitfor) + struct vcache *avc; + int fflags; + struct AFS_UCRED *acred; + int waitfor; +{ + int code; + AFS_GLOCK(); + code = afs_fsync(avc, fflags, acred, waitfor); + AFS_GUNLOCK(); + return code; +} + +mp_afs_remove(ndp) + struct nameidata *ndp; +{ + int code; + AFS_GLOCK(); + code = afs_remove(ndp); + AFS_GUNLOCK(); + return code; +} + +mp_afs_link(avc, ndp) + struct vcache *avc; + struct nameidata *ndp; +{ + int code; + AFS_GLOCK(); + code = afs_link(avc, ndp); + AFS_GUNLOCK(); + return code; +} + +mp_afs_rename(fndp, tndp) + struct nameidata *fndp, *tndp; +{ + int code; + AFS_GLOCK(); + code = afs_rename(fndp, tndp); + AFS_GUNLOCK(); + return code; +} + +mp_afs_mkdir(ndp, attrs) + struct nameidata *ndp; + struct vattr *attrs; +{ + int code; + AFS_GLOCK(); + code = afs_mkdir(ndp, attrs); + AFS_GUNLOCK(); + return code; +} + +mp_afs_rmdir(ndp) + struct nameidata *ndp; +{ + int code; + AFS_GLOCK(); + code = afs_rmdir(ndp); + AFS_GUNLOCK(); + return code; +} + +mp_afs_symlink(ndp, attrs, atargetName) + struct nameidata *ndp; + struct vattr *attrs; + register char *atargetName; +{ + int code; + AFS_GLOCK(); + code = afs_symlink(ndp, attrs, atargetName); + AFS_GUNLOCK(); + return code; +} + +mp_afs_readdir(avc, auio, acred, eofp) + struct vcache *avc; + struct uio *auio; + struct AFS_UCRED *acred; + int *eofp; +{ + int code; + AFS_GLOCK(); + code = afs_readdir(avc, auio, acred, eofp); + AFS_GUNLOCK(); + return code; +} + +mp_afs_readlink(avc, auio, acred) + struct vcache *avc; + struct uio *auio; + struct AFS_UCRED *acred; +{ + int code; + AFS_GLOCK(); + code = afs_readlink(avc, auio, acred); + AFS_GUNLOCK(); + return code; +} + +mp_afs_lockctl(avc, af, flag, acred, clid, offset) + struct vcache *avc; + struct eflock *af; + struct AFS_UCRED *acred; + int flag; + pid_t clid; + off_t offset; +{ + int code; + AFS_GLOCK(); + code = afs_lockctl(avc, af, flag, acred, clid, offset); + AFS_GUNLOCK(); + return code; +} + +mp_afs_closex(afd) + struct file *afd; +{ + int code; + AFS_GLOCK(); + code = afs_closex(afd); + AFS_GUNLOCK(); + return code; +} + +mp_afs_seek(avc, oldoff, newoff, cred) + struct vcache *avc; + off_t oldoff, newoff; + struct ucred *cred; +{ + if ((int) newoff < 0) + return(EINVAL); + else + return(0); +} + +mp_afs_abortop(ndp) + struct nameidata *ndp; +{ + return(0); +} + +mp_afs_inactive(avc, acred) + register struct vcache *avc; + struct AFS_UCRED *acred; +{ + AFS_GLOCK(); + afs_InactiveVCache(avc, acred); + AFS_GUNLOCK(); +} + + +mp_afs_reclaim(avc) + struct vcache *avc; +{ + return(0); +} + +mp_afs_print(avc) + struct vcache *avc; +{ + return(0); +} + +mp_afs_page_read(avc, uio, acred) + struct vcache *avc; + struct uio *uio; + struct ucred *acred; +{ + int error; + struct vrequest treq; + + AFS_GLOCK(); + error = afs_rdwr(avc, uio, UIO_READ, 0, acred); + afs_Trace3(afs_iclSetp, CM_TRACE_PAGE_READ, ICL_TYPE_POINTER, avc, + ICL_TYPE_INT32, error, ICL_TYPE_INT32, avc->states); + if (error) { + error = EIO; + } else if ((avc->states) == 0) { + afs_InitReq(&treq, acred); + ObtainWriteLock(&avc->lock,161); + afs_Wire(avc, &treq); + ReleaseWriteLock(&avc->lock); + } + AFS_GUNLOCK(); + return(error); +} + + +mp_afs_page_write(avc, uio, acred, pager, offset) + struct vcache *avc; + struct uio *uio; + struct ucred *acred; + memory_object_t pager; + vm_offset_t offset; +{ + int error; + + AFS_GLOCK(); + error = afs_rdwr(avc, uio, UIO_WRITE, 0, acred); + afs_Trace3(afs_iclSetp, CM_TRACE_PAGE_WRITE, ICL_TYPE_POINTER, avc, + ICL_TYPE_INT32, error, ICL_TYPE_INT32, avc->states); + if (error) { + error = EIO; + } + AFS_GUNLOCK(); + return(error); +} + + +int DO_FLUSH=1; +mp_afs_ubcrdwr(avc, uio, ioflag, cred) + struct vcache *avc; + struct uio *uio; + int ioflag; + struct ucred *cred; +{ + register afs_int32 code; + register char *data; + afs_int32 fileBase, size, cnt=0; + afs_int32 pageBase; + register afs_int32 tsize; + register afs_int32 pageOffset; + int eof; + struct vrequest treq; + int rw = uio->uio_rw; + int rv, flags; + int newpage=0; + vm_page_t page; + afs_int32 save_resid; + struct dcache *tdc; + int didFakeOpen=0; + int counter=0; + + AFS_GLOCK(); + afs_InitReq(&treq, cred); + if (AFS_NFSXLATORREQ(cred) && rw == UIO_READ) { + if (!afs_AccessOK(avc, PRSFS_READ, &treq, + CHECK_MODE_BITS|CMB_ALLOW_EXEC_AS_READ)) { + AFS_GUNLOCK(); + return EACCES; + } + } + afs_Trace4(afs_iclSetp, CM_TRACE_VMRW, ICL_TYPE_POINTER, avc, + ICL_TYPE_INT32, (rw==UIO_WRITE? 1 : 0), + ICL_TYPE_LONG, uio->uio_offset, + ICL_TYPE_LONG, uio->uio_resid); + code = afs_VerifyVCache(avc, &treq); + if (code) { + code = afs_CheckCode(code, &treq, 35); + AFS_GUNLOCK(); + return code; + } + if (vType(avc) != VREG) { + AFS_GUNLOCK(); + return EISDIR; /* can't read or write other things */ + } + afs_BozonLock(&avc->pvnLock, avc); + osi_FlushPages(avc); /* hold bozon lock, but not basic vnode lock */ + ObtainWriteLock(&avc->lock,162); + /* adjust parameters when appending files */ + if ((ioflag & IO_APPEND) && uio->uio_rw == UIO_WRITE) + uio->uio_offset = avc->m.Length; /* write at EOF position */ + if (uio->uio_rw == UIO_WRITE) { + avc->states |= CDirty; + afs_FakeOpen(avc); + didFakeOpen=1; + /* + * before starting any I/O, we must ensure that the file is big enough + * to hold the results (since afs_putpage will be called to force + * the I/O. + */ + size = uio->afsio_resid + uio->afsio_offset; /* new file size */ + if (size > avc->m.Length) avc->m.Length = size; /* file grew */ + avc->m.Date = osi_Time(); /* Set file date (for ranlib) */ + if (uio->afsio_resid > PAGE_SIZE) + cnt = uio->afsio_resid / PAGE_SIZE; + save_resid = uio->afsio_resid; + } + + while (1) { + /* + * compute the amount of data to move into this block, + * based on uio->afsio_resid. + */ + size = uio->afsio_resid; /* transfer size */ + fileBase = uio->afsio_offset; /* start file position */ + pageBase = fileBase & ~(PAGE_SIZE-1); /* file position of the page */ + pageOffset = fileBase & (PAGE_SIZE-1); /* start offset within page */ + tsize = PAGE_SIZE-pageOffset; /* amount left in this page */ + /* + * we'll read tsize bytes, + * but first must make sure tsize isn't too big + */ + if (tsize > size) tsize = size; /* don't read past end of request */ + eof = 0; /* flag telling us if we hit the EOF on the read */ + if (uio->uio_rw == UIO_READ) { /* we're doing a read operation */ + /* don't read past EOF */ + if (tsize + fileBase > avc->m.Length) { + tsize = avc->m.Length - fileBase; + eof = 1; /* we did hit the EOF */ + if (tsize < 0) tsize = 0; /* better safe than sorry */ + } + } + if (tsize <= 0) break; /* nothing to transfer, we're done */ + + /* Purge dirty chunks of file if there are too many dirty chunks. + * Inside the write loop, we only do this at a chunk boundary. + * Clean up partial chunk if necessary at end of loop. + */ + if (uio->uio_rw == UIO_WRITE && counter > 0 + && AFS_CHUNKOFFSET(fileBase) == 0) { + code = afs_DoPartialWrite(avc, &treq); + avc->states |= CDirty; + } + + if (code) { + break; + } + + flags = 0; + ReleaseWriteLock(&avc->lock); + AFS_GUNLOCK(); + code = ubc_lookup(((struct vnode *)avc)->v_object, pageBase, + PAGE_SIZE, PAGE_SIZE, &page, &flags); + AFS_GLOCK(); + ObtainWriteLock(&avc->lock,163); + + if (code) { + break; + } + if (flags & B_NOCACHE) { + /* + No page found. We should not read the page in if + 1. the write starts on a page edge (ie, pageoffset == 0) + and either + 1. we will fill the page (ie, size == PAGESIZE), or + 2. we are writing past eof + */ + if ((uio->uio_rw == UIO_WRITE) && + ((pageOffset == 0 && (size == PAGE_SIZE || fileBase >= avc->m.Length)))) { + struct vnode *vp = (struct vnode *)avc; + /* we're doing a write operation past eof; no need to read it */ + newpage = 1; + AFS_GUNLOCK(); + ubc_page_zero(page, 0, PAGE_SIZE); + ubc_page_release(page, B_DONE); + AFS_GLOCK(); + } else { + /* page wasn't cached, read it in. */ + struct buf *bp; + + AFS_GUNLOCK(); + bp = ubc_bufalloc(page, 1, PAGE_SIZE, 1, B_READ); + AFS_GLOCK(); + bp->b_dev = 0; + bp->b_vp = (struct vnode *)avc; + bp->b_blkno = btodb(pageBase); + ReleaseWriteLock(&avc->lock); + code = afs_ustrategy(bp, cred); /* do the I/O */ + ObtainWriteLock(&avc->lock,164); + AFS_GUNLOCK(); + ubc_sync_iodone(bp); + AFS_GLOCK(); + if (code) { + AFS_GUNLOCK(); + ubc_page_release(page, 0); + AFS_GLOCK(); + break; + } + } + } + AFS_GUNLOCK(); + ubc_page_wait(page); + data = (char *)page->pg_addr; /* DUX 4.0D */ + if (data == 0) + data = (char *)PHYS_TO_KSEG(page->pg_phys_addr); /* DUX 4.0E */ + AFS_GLOCK(); + ReleaseWriteLock(&avc->lock); /* uiomove may page fault */ + AFS_GUNLOCK(); + code = uiomove(data+pageOffset, tsize, uio); + ubc_unload(page, pageOffset, page_size); + if (uio->uio_rw == UIO_WRITE) { + vm_offset_t toffset; + + /* Mark the page dirty and release it to avoid a deadlock + * in ubc_dirty_kluster when more than one process writes + * this page at the same time. */ + toffset = page->pg_offset; + flags |= B_DIRTY; + ubc_page_release(page, flags); + + if (cnt > 10) { + vm_page_t pl; + int kpcnt; + struct buf *bp; + + /* We released the page, so we can get a null page + * list if another thread calls the strategy routine. + */ + pl = ubc_dirty_kluster(((struct vnode *)avc)->v_object, + NULL, toffset, 0, B_WANTED, FALSE, &kpcnt); + if (pl) { + bp = ubc_bufalloc(pl, 1, PAGE_SIZE, 1, B_WRITE); + bp->b_dev = 0; + bp->b_vp = (struct vnode *)avc; + bp->b_blkno = btodb(pageBase); + AFS_GLOCK(); + code = afs_ustrategy(bp, cred); /* do the I/O */ + AFS_GUNLOCK(); + ubc_sync_iodone(bp); + if (code) { + AFS_GLOCK(); + ObtainWriteLock(&avc->lock,415); + break; + } + } + } + } else { + ubc_page_release(page, flags); + } + AFS_GLOCK(); + ObtainWriteLock(&avc->lock,165); + /* + * If reading at a chunk boundary, start prefetch of next chunk. + */ + if (uio->uio_rw == UIO_READ + && (counter == 0 || AFS_CHUNKOFFSET(fileBase) == 0)) { + tdc = afs_FindDCache(avc, fileBase); + if (tdc) { + if (!(tdc->flags & DFNextStarted)) + afs_PrefetchChunk(avc, tdc, cred, &treq); + afs_PutDCache(tdc); + } + } + counter++; + if (code) break; + } + if (didFakeOpen) + afs_FakeClose(avc, cred); + if (uio->uio_rw == UIO_WRITE && code == 0 && (avc->states & CDirty)) { + code = afs_DoPartialWrite(avc, &treq); + } + ReleaseWriteLock(&avc->lock); + afs_BozonUnlock(&avc->pvnLock, avc); + if (DO_FLUSH || (!newpage && (cnt < 10))) { + AFS_GUNLOCK(); + ubc_flush_dirty(((struct vnode *)avc)->v_object, flags); + AFS_GLOCK(); + } + + ObtainSharedLock(&avc->lock, 409); + if (!code) { + if (avc->vc_error) { + code = avc->vc_error; + } + } + /* This is required since we may still have dirty pages after the write. + * I could just let close do the right thing, but stat's before the close + * return the wrong length. + */ + if (code == EDQUOT || code == ENOSPC) { + uio->uio_resid = save_resid; + UpgradeSToWLock(&avc->lock, 410); + osi_ReleaseVM(avc, cred); + ConvertWToSLock(&avc->lock); + } + ReleaseSharedLock(&avc->lock); + + if (!code && (ioflag & IO_SYNC) && (uio->uio_rw == UIO_WRITE) + && !AFS_NFSXLATORREQ(cred)) { + code = afs_fsync(avc, 0, cred, 0); + } +out: + code = afs_CheckCode(code, &treq, 36); + AFS_GUNLOCK(); + return code; +} + + +/* + * Now for some bad news. Since we artificially hold on to vnodes by doing + * and extra VNHOLD in afs_NewVCache(), there is no way for us to know + * when we need to flush the pages when a program exits. Particularly + * if it closes the file after mapping it R/W. + * + */ + +mp_afs_mmap(avc, offset, map, addrp, len, prot, maxprot, flags, cred) + register struct vcache *avc; + vm_offset_t offset; + vm_map_t map; + vm_offset_t *addrp; + vm_size_t len; + vm_prot_t prot; + vm_prot_t maxprot; + int flags; + struct ucred *cred; +{ + struct vp_mmap_args args; + register struct vp_mmap_args *ap = &args; + struct vnode *vp = (struct vnode *)avc; + int code; + struct vrequest treq; +#if !defined(DYNEL) + extern kern_return_t u_vp_create(); +#endif + + AFS_GLOCK(); + afs_InitReq(&treq, cred); + code = afs_VerifyVCache(avc, &treq); + if (code) { + code = afs_CheckCode(code, &treq, 37); + AFS_GUNLOCK(); + return code; + } + afs_BozonLock(&avc->pvnLock, avc); + osi_FlushPages(avc); /* ensure old pages are gone */ + afs_BozonUnlock(&avc->pvnLock, avc); + ObtainWriteLock(&avc->lock,166); + avc->states |= CMAPPED; + ReleaseWriteLock(&avc->lock); + ap->a_offset = offset; + ap->a_vaddr = addrp; + ap->a_size = len; + ap->a_prot = prot, + ap->a_maxprot = maxprot; + ap->a_flags = flags; + AFS_GUNLOCK(); + code = u_vp_create(map, vp->v_object, (vm_offset_t) ap); + AFS_GLOCK(); + code = afs_CheckCode(code, &treq, 38); + AFS_GUNLOCK(); + return code; +} + + +int mp_afs_getpage(vop, offset, len, protp, pl, plsz, mape, addr, rw, cred) + vm_ubc_object_t vop; + vm_offset_t offset; + vm_size_t len; + vm_prot_t *protp; + vm_page_t *pl; + int plsz; + vm_map_entry_t mape; + vm_offset_t addr; + int rw; + struct ucred *cred; +{ + register afs_int32 code; + struct vrequest treq; + int flags = 0; + int i, pages = (len + PAGE_SIZE - 1) >> page_shift; + vm_page_t *pagep; + vm_offset_t off; + + struct vcache *avc = (struct vcache *)vop->vu_vp; + + /* first, obtain the proper lock for the VM system */ + + AFS_GLOCK(); + afs_InitReq(&treq, cred); + code = afs_VerifyVCache(avc, &treq); + if (code) { + *pl = VM_PAGE_NULL; + code = afs_CheckCode(code, &treq, 39); /* failed to get it */ + AFS_GUNLOCK(); + return code; + } + + /* clean all dirty pages for this vnode */ + AFS_GUNLOCK(); + ubc_flush_dirty(vop,0); + AFS_GLOCK(); + + afs_BozonLock(&avc->pvnLock, avc); + ObtainWriteLock(&avc->lock,167); + afs_Trace4(afs_iclSetp, CM_TRACE_PAGEIN, ICL_TYPE_POINTER, avc, + ICL_TYPE_LONG, offset, ICL_TYPE_LONG, len, + ICL_TYPE_INT32, (int) rw); + for (i = 0; i < pages; i++) { + pagep = &pl[i]; + off = offset + PAGE_SIZE * i; + if (protp) protp[i] = 0; + flags = 0; + ReleaseWriteLock(&avc->lock); + AFS_GUNLOCK(); + code = ubc_lookup(((struct vnode *)avc)->v_object, off, + PAGE_SIZE, PAGE_SIZE, pagep, &flags); + AFS_GLOCK(); + ObtainWriteLock(&avc->lock,168); + if (code) { + goto out; + } + if(flags & B_NOCACHE) { /* if (page) */ + if ((rw & B_WRITE) && (offset+len >= avc->m.Length)) { + struct vnode *vp = (struct vnode *)avc; + /* we're doing a write operation past eof; no need to read it */ + AFS_GUNLOCK(); + ubc_page_zero(*pagep, 0, PAGE_SIZE); + ubc_page_release(*pagep, B_DONE); + AFS_GLOCK(); + } else { + /* page wasn't cached, read it in. */ + struct buf *bp; + + AFS_GUNLOCK(); + bp = ubc_bufalloc(*pagep, 1, PAGE_SIZE, 1, B_READ); + AFS_GLOCK(); + bp->b_dev = 0; + bp->b_vp = (struct vnode *)avc; + bp->b_blkno = btodb(off); + ReleaseWriteLock(&avc->lock); + code = afs_ustrategy(bp, cred); /* do the I/O */ + ObtainWriteLock(&avc->lock,169); + AFS_GUNLOCK(); + ubc_sync_iodone(bp); + AFS_GLOCK(); + if (code) { + AFS_GUNLOCK(); + ubc_page_release(pl[i], 0); + AFS_GLOCK(); + goto out; + } + } + } + if ((rw & B_READ) == 0) { + AFS_GUNLOCK(); + ubc_page_dirty(pl[i]); + AFS_GLOCK(); + } else { + if (protp && (flags & B_DIRTY) == 0) { + protp[i] = VM_PROT_WRITE; + } + } + } +out: + pl[i] = VM_PAGE_NULL; + ReleaseWriteLock(&avc->lock); + afs_BozonUnlock(&avc->pvnLock, avc); + afs_Trace3(afs_iclSetp, CM_TRACE_PAGEINDONE, ICL_TYPE_INT32, code, + ICL_TYPE_POINTER, *pagep, ICL_TYPE_INT32, flags); + code = afs_CheckCode(code, &treq, 40); + AFS_GUNLOCK(); + return code; +} + + +int mp_afs_putpage(vop, pl, pcnt, flags, cred) + vm_ubc_object_t vop; + vm_page_t *pl; + int pcnt; + int flags; + struct ucred *cred; +{ + register afs_int32 code=0; + struct vcache *avc = (struct vcache *)vop->vu_vp; + struct vnode *vp = (struct vnode *)avc; + int i; + + AFS_GLOCK(); + afs_Trace4(afs_iclSetp, CM_TRACE_PAGEOUT, ICL_TYPE_POINTER, avc, + ICL_TYPE_INT32, pcnt, ICL_TYPE_INT32, vp->v_flag, + ICL_TYPE_INT32, flags); + if (flags & B_UBC) { + AFS_GUNLOCK(); + VN_LOCK(vp); + if (vp->v_flag & VXLOCK) { + VN_UNLOCK(vp); + for (i = 0; i < pcnt; i++) { + ubc_page_release(pl[i], B_DONE|B_DIRTY); + pl[i] = VM_PAGE_NULL; + } + return(0); + } else { + VN_UNLOCK(vp); + } + AFS_GLOCK(); + } + + /* first, obtain the proper lock for the VM system */ + afs_BozonLock(&avc->pvnLock, avc); + ObtainWriteLock(&avc->lock,170); + for (i = 0; i < pcnt; i++) { + vm_page_t page = pl[i]; + struct buf *bp; + + /* write it out */ + AFS_GUNLOCK(); + bp = ubc_bufalloc(page, 1, PAGE_SIZE, 1, B_WRITE); + AFS_GLOCK(); + bp->b_dev = 0; + bp->b_vp = (struct vnode *)avc; + bp->b_blkno = btodb(page->pg_offset); + ReleaseWriteLock(&avc->lock); + code = afs_ustrategy(bp, cred); /* do the I/O */ + ObtainWriteLock(&avc->lock,171); + AFS_GUNLOCK(); + ubc_sync_iodone(bp); + AFS_GLOCK(); + if (code) { + goto done; + } else { + pl[i] = VM_PAGE_NULL; + } + } +done: + ReleaseWriteLock(&avc->lock); + afs_BozonUnlock(&avc->pvnLock, avc); + afs_Trace2(afs_iclSetp, CM_TRACE_PAGEOUTDONE, ICL_TYPE_INT32, code, + ICL_TYPE_INT32, avc->m.Length); + AFS_GUNLOCK(); + return code; +} + + +int mp_afs_swap(avc, swapop, argp) + struct vcache *avc; + vp_swap_op_t swapop; + vm_offset_t argp; +{ + return EIO; +} + +int mp_afs_syncdata(avc, flag, offset, length, cred) + struct vcache *avc; + int flag; + vm_offset_t offset; + vm_size_t length; + struct ucred *cred; +{ + /* NFS V3 makes this call, ignore it. We'll sync the data in afs_fsync. */ + if (AFS_NFSXLATORREQ(cred)) + return 0; + else + return EINVAL; +} + +/* a freelist of one */ +struct buf *afs_bread_freebp = 0; + +/* + * Only rfs_read calls this, and it only looks at bp->b_un.b_addr. + * Thus we can use fake bufs (ie not from the real buffer pool). + */ +mp_afs_bread(vp, lbn, bpp, cred) + struct ucred *cred; + struct vnode *vp; + daddr_t lbn; + struct buf **bpp; +{ + int offset, fsbsize, error; + struct buf *bp; + struct iovec iov; + struct uio uio; + + AFS_GLOCK(); + AFS_STATCNT(afs_bread); + fsbsize = vp->v_vfsp->vfs_bsize; + offset = lbn * fsbsize; + if (afs_bread_freebp) { + bp = afs_bread_freebp; + afs_bread_freebp = 0; + } else { + bp = (struct buf *) AFS_KALLOC(sizeof(*bp)); + bp->b_un.b_addr = (caddr_t) AFS_KALLOC(fsbsize); + } + + iov.iov_base = bp->b_un.b_addr; + iov.iov_len = fsbsize; + uio.afsio_iov = &iov; + uio.afsio_iovcnt = 1; + uio.afsio_seg = AFS_UIOSYS; + uio.afsio_offset = offset; + uio.afsio_resid = fsbsize; + *bpp = 0; + error = afs_read((struct vcache *)vp, &uio, cred, lbn, bpp, 0); + if (error) { + afs_bread_freebp = bp; + AFS_GUNLOCK(); + return error; + } + if (*bpp) { + afs_bread_freebp = bp; + } else { + *(struct buf **)&bp->b_vp = bp; /* mark as fake */ + *bpp = bp; + } + AFS_GUNLOCK(); + return 0; +} + + +mp_afs_brelse(vp, bp) +struct vnode *vp; +struct buf *bp; +{ + AFS_GLOCK(); + AFS_STATCNT(afs_brelse); + if ((struct buf *)bp->b_vp != bp) { /* not fake */ + brelse(bp); + } else if (afs_bread_freebp) { + AFS_KFREE(bp->b_un.b_addr, vp->v_vfsp->vfs_bsize); + AFS_KFREE(bp, sizeof(*bp)); + } else { + afs_bread_freebp = bp; + } + AFS_GUNLOCK(); +} + + +mp_afs_bmap(avc, abn, anvp, anbn) + register struct vcache *avc; + afs_int32 abn, *anbn; + struct vcache **anvp; +{ + AFS_GLOCK(); + AFS_STATCNT(afs_bmap); + if (anvp) + *anvp = avc; + if (anbn) + *anbn = abn * (8192 / DEV_BSIZE); /* in 512 byte units */ + AFS_GUNLOCK(); + return 0; +} + + +/* real strategy */ +mp_afs_strategy (abp) + register struct buf *abp; +{ + register afs_int32 code; + + AFS_GLOCK(); + AFS_STATCNT(afs_strategy); + code = afs_osi_MapStrategy(afs_ustrategy, abp); + AFS_GUNLOCK(); + return code; +} + + +mp_afs_refer(vm_ubc_object_t vop) +{ + VREF(vop->vu_vp); +} + + +mp_afs_release(vm_ubc_object_t vop) +{ + vrele(vop->vu_vp); +} + + +mp_afs_write_check(vm_ubc_object_t vop, vm_page_t pp) +{ + return TRUE; +} + + + +struct vfs_ubcops afs_ubcops = { + mp_afs_refer, /* refer vnode */ + mp_afs_release, /* release vnode */ + mp_afs_getpage, /* get page */ + mp_afs_putpage, /* put page */ + mp_afs_write_check, /* check writablity */ +}; +#endif /* 0 */ + +/* + * Cover function for lookup name using OSF equivalent, namei() + * + * Note, the result vnode (ni_vp) in the namei data structure is remains + * locked after return. + */ +lookupname(namep, seg, follow, dvpp, cvpp) + char *namep; /* path name */ + int seg; /* address space containing name */ + int follow; /* follow symbolic links */ + struct vnode **dvpp; /* result, containing parent vnode */ + struct vnode **cvpp; /* result, containing final component vnode */ +{ + /* Should I use free-bee in u-area? */ + struct nameidata *ndp = &u.u_nd; + int error; + + ndp->ni_nameiop = ((follow) ? (LOOKUP|FOLLOW) : (LOOKUP)); + ndp->ni_segflg = seg; + ndp->ni_dirp = namep; + error = namei(ndp); + if (dvpp != (struct vnode **)0) + *dvpp = ndp->ni_dvp; + if (cvpp != (struct vnode **)0) + *cvpp = ndp->ni_vp; + return(error); +} + diff --git a/src/afs/FBSD/vnode_if.h b/src/afs/FBSD/vnode_if.h new file mode 100644 index 0000000..7c4da8f --- /dev/null +++ b/src/afs/FBSD/vnode_if.h @@ -0,0 +1,1348 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + +/* + * This file is produced automatically. + * Do not modify anything in here by hand. + * + * Created from @(#)vnode_if.sh 8.1 (Berkeley) 6/10/93 + */ + +extern struct vnodeop_desc vop_default_desc; +struct vop_islocked_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_islocked_desc; +static __inline int VOP_ISLOCKED __P(( + struct vnode *vp, + struct proc *p)); +static __inline int VOP_ISLOCKED(vp, p) + struct vnode *vp; + struct proc *p; +{ + struct vop_islocked_args a; + int rc; + a.a_desc = VDESC(vop_islocked); + a.a_vp = vp; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_islocked), &a); + return (rc); +} +struct vop_lookup_args { + struct vnodeop_desc *a_desc; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; +}; +extern struct vnodeop_desc vop_lookup_desc; +static __inline int VOP_LOOKUP __P(( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp)); +static __inline int VOP_LOOKUP(dvp, vpp, cnp) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; +{ + struct vop_lookup_args a; + int rc; + a.a_desc = VDESC(vop_lookup); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + rc = VCALL(dvp, VOFFSET(vop_lookup), &a); + return (rc); +} +struct vop_cachedlookup_args { + struct vnodeop_desc *a_desc; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; +}; +extern struct vnodeop_desc vop_cachedlookup_desc; +static __inline int VOP_CACHEDLOOKUP __P(( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp)); +static __inline int VOP_CACHEDLOOKUP(dvp, vpp, cnp) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; +{ + struct vop_cachedlookup_args a; + int rc; + a.a_desc = VDESC(vop_cachedlookup); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + rc = VCALL(dvp, VOFFSET(vop_cachedlookup), &a); + return (rc); +} +struct vop_create_args { + struct vnodeop_desc *a_desc; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; +}; +extern struct vnodeop_desc vop_create_desc; +static __inline int VOP_CREATE __P(( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp, + struct vattr *vap)); +static __inline int VOP_CREATE(dvp, vpp, cnp, vap) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; + struct vattr *vap; +{ + struct vop_create_args a; + int rc; + a.a_desc = VDESC(vop_create); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + rc = VCALL(dvp, VOFFSET(vop_create), &a); + return (rc); +} +struct vop_whiteout_args { + struct vnodeop_desc *a_desc; + struct vnode *a_dvp; + struct componentname *a_cnp; + int a_flags; +}; +extern struct vnodeop_desc vop_whiteout_desc; +static __inline int VOP_WHITEOUT __P(( + struct vnode *dvp, + struct componentname *cnp, + int flags)); +static __inline int VOP_WHITEOUT(dvp, cnp, flags) + struct vnode *dvp; + struct componentname *cnp; + int flags; +{ + struct vop_whiteout_args a; + int rc; + a.a_desc = VDESC(vop_whiteout); + a.a_dvp = dvp; + a.a_cnp = cnp; + a.a_flags = flags; + rc = VCALL(dvp, VOFFSET(vop_whiteout), &a); + return (rc); +} +struct vop_mknod_args { + struct vnodeop_desc *a_desc; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; +}; +extern struct vnodeop_desc vop_mknod_desc; +static __inline int VOP_MKNOD __P(( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp, + struct vattr *vap)); +static __inline int VOP_MKNOD(dvp, vpp, cnp, vap) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; + struct vattr *vap; +{ + struct vop_mknod_args a; + int rc; + a.a_desc = VDESC(vop_mknod); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + rc = VCALL(dvp, VOFFSET(vop_mknod), &a); + return (rc); +} +struct vop_open_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_open_desc; +static __inline int VOP_OPEN __P(( + struct vnode *vp, + int mode, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_OPEN(vp, mode, cred, p) + struct vnode *vp; + int mode; + struct ucred *cred; + struct proc *p; +{ + struct vop_open_args a; + int rc; + a.a_desc = VDESC(vop_open); + a.a_vp = vp; + a.a_mode = mode; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_open), &a); + return (rc); +} +struct vop_close_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_close_desc; +static __inline int VOP_CLOSE __P(( + struct vnode *vp, + int fflag, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_CLOSE(vp, fflag, cred, p) + struct vnode *vp; + int fflag; + struct ucred *cred; + struct proc *p; +{ + struct vop_close_args a; + int rc; + a.a_desc = VDESC(vop_close); + a.a_vp = vp; + a.a_fflag = fflag; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_close), &a); + return (rc); +} +struct vop_access_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_access_desc; +static __inline int VOP_ACCESS __P(( + struct vnode *vp, + int mode, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_ACCESS(vp, mode, cred, p) + struct vnode *vp; + int mode; + struct ucred *cred; + struct proc *p; +{ + struct vop_access_args a; + int rc; + a.a_desc = VDESC(vop_access); + a.a_vp = vp; + a.a_mode = mode; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_access), &a); + return (rc); +} +struct vop_getattr_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_getattr_desc; +static __inline int VOP_GETATTR __P(( + struct vnode *vp, + struct vattr *vap, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_GETATTR(vp, vap, cred, p) + struct vnode *vp; + struct vattr *vap; + struct ucred *cred; + struct proc *p; +{ + struct vop_getattr_args a; + int rc; + a.a_desc = VDESC(vop_getattr); + a.a_vp = vp; + a.a_vap = vap; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_getattr), &a); + return (rc); +} +struct vop_setattr_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_setattr_desc; +static __inline int VOP_SETATTR __P(( + struct vnode *vp, + struct vattr *vap, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_SETATTR(vp, vap, cred, p) + struct vnode *vp; + struct vattr *vap; + struct ucred *cred; + struct proc *p; +{ + struct vop_setattr_args a; + int rc; + a.a_desc = VDESC(vop_setattr); + a.a_vp = vp; + a.a_vap = vap; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_setattr), &a); + return (rc); +} +struct vop_read_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; +}; +extern struct vnodeop_desc vop_read_desc; +static __inline int VOP_READ __P(( + struct vnode *vp, + struct uio *uio, + int ioflag, + struct ucred *cred)); +static __inline int VOP_READ(vp, uio, ioflag, cred) + struct vnode *vp; + struct uio *uio; + int ioflag; + struct ucred *cred; +{ + struct vop_read_args a; + int rc; + a.a_desc = VDESC(vop_read); + a.a_vp = vp; + a.a_uio = uio; + a.a_ioflag = ioflag; + a.a_cred = cred; + rc = VCALL(vp, VOFFSET(vop_read), &a); + return (rc); +} +struct vop_write_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; +}; +extern struct vnodeop_desc vop_write_desc; +static __inline int VOP_WRITE __P(( + struct vnode *vp, + struct uio *uio, + int ioflag, + struct ucred *cred)); +static __inline int VOP_WRITE(vp, uio, ioflag, cred) + struct vnode *vp; + struct uio *uio; + int ioflag; + struct ucred *cred; +{ + struct vop_write_args a; + int rc; + a.a_desc = VDESC(vop_write); + a.a_vp = vp; + a.a_uio = uio; + a.a_ioflag = ioflag; + a.a_cred = cred; + rc = VCALL(vp, VOFFSET(vop_write), &a); + return (rc); +} +struct vop_lease_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct proc *a_p; + struct ucred *a_cred; + int a_flag; +}; +extern struct vnodeop_desc vop_lease_desc; +static __inline int VOP_LEASE __P(( + struct vnode *vp, + struct proc *p, + struct ucred *cred, + int flag)); +static __inline int VOP_LEASE(vp, p, cred, flag) + struct vnode *vp; + struct proc *p; + struct ucred *cred; + int flag; +{ + struct vop_lease_args a; + int rc; + a.a_desc = VDESC(vop_lease); + a.a_vp = vp; + a.a_p = p; + a.a_cred = cred; + a.a_flag = flag; + rc = VCALL(vp, VOFFSET(vop_lease), &a); + return (rc); +} +struct vop_ioctl_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + u_long a_command; + caddr_t a_data; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_ioctl_desc; +static __inline int VOP_IOCTL __P(( + struct vnode *vp, + u_long command, + caddr_t data, + int fflag, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_IOCTL(vp, command, data, fflag, cred, p) + struct vnode *vp; + u_long command; + caddr_t data; + int fflag; + struct ucred *cred; + struct proc *p; +{ + struct vop_ioctl_args a; + int rc; + a.a_desc = VDESC(vop_ioctl); + a.a_vp = vp; + a.a_command = command; + a.a_data = data; + a.a_fflag = fflag; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_ioctl), &a); + return (rc); +} +struct vop_poll_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + int a_events; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_poll_desc; +static __inline int VOP_POLL __P(( + struct vnode *vp, + int events, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_POLL(vp, events, cred, p) + struct vnode *vp; + int events; + struct ucred *cred; + struct proc *p; +{ + struct vop_poll_args a; + int rc; + a.a_desc = VDESC(vop_poll); + a.a_vp = vp; + a.a_events = events; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_poll), &a); + return (rc); +} +struct vop_revoke_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + int a_flags; +}; +extern struct vnodeop_desc vop_revoke_desc; +static __inline int VOP_REVOKE __P(( + struct vnode *vp, + int flags)); +static __inline int VOP_REVOKE(vp, flags) + struct vnode *vp; + int flags; +{ + struct vop_revoke_args a; + int rc; + a.a_desc = VDESC(vop_revoke); + a.a_vp = vp; + a.a_flags = flags; + rc = VCALL(vp, VOFFSET(vop_revoke), &a); + return (rc); +} +struct vop_mmap_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + int a_fflags; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_mmap_desc; +static __inline int VOP_MMAP __P(( + struct vnode *vp, + int fflags, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_MMAP(vp, fflags, cred, p) + struct vnode *vp; + int fflags; + struct ucred *cred; + struct proc *p; +{ + struct vop_mmap_args a; + int rc; + a.a_desc = VDESC(vop_mmap); + a.a_vp = vp; + a.a_fflags = fflags; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_mmap), &a); + return (rc); +} +struct vop_fsync_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct ucred *a_cred; + int a_waitfor; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_fsync_desc; +static __inline int VOP_FSYNC __P(( + struct vnode *vp, + struct ucred *cred, + int waitfor, + struct proc *p)); +static __inline int VOP_FSYNC(vp, cred, waitfor, p) + struct vnode *vp; + struct ucred *cred; + int waitfor; + struct proc *p; +{ + struct vop_fsync_args a; + int rc; + a.a_desc = VDESC(vop_fsync); + a.a_vp = vp; + a.a_cred = cred; + a.a_waitfor = waitfor; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_fsync), &a); + return (rc); +} +struct vop_remove_args { + struct vnodeop_desc *a_desc; + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; +}; +extern struct vnodeop_desc vop_remove_desc; +static __inline int VOP_REMOVE __P(( + struct vnode *dvp, + struct vnode *vp, + struct componentname *cnp)); +static __inline int VOP_REMOVE(dvp, vp, cnp) + struct vnode *dvp; + struct vnode *vp; + struct componentname *cnp; +{ + struct vop_remove_args a; + int rc; + a.a_desc = VDESC(vop_remove); + a.a_dvp = dvp; + a.a_vp = vp; + a.a_cnp = cnp; + rc = VCALL(dvp, VOFFSET(vop_remove), &a); + return (rc); +} +struct vop_link_args { + struct vnodeop_desc *a_desc; + struct vnode *a_tdvp; + struct vnode *a_vp; + struct componentname *a_cnp; +}; +extern struct vnodeop_desc vop_link_desc; +static __inline int VOP_LINK __P(( + struct vnode *tdvp, + struct vnode *vp, + struct componentname *cnp)); +static __inline int VOP_LINK(tdvp, vp, cnp) + struct vnode *tdvp; + struct vnode *vp; + struct componentname *cnp; +{ + struct vop_link_args a; + int rc; + a.a_desc = VDESC(vop_link); + a.a_tdvp = tdvp; + a.a_vp = vp; + a.a_cnp = cnp; + rc = VCALL(tdvp, VOFFSET(vop_link), &a); + return (rc); +} +struct vop_rename_args { + struct vnodeop_desc *a_desc; + struct vnode *a_fdvp; + struct vnode *a_fvp; + struct componentname *a_fcnp; + struct vnode *a_tdvp; + struct vnode *a_tvp; + struct componentname *a_tcnp; +}; +extern struct vnodeop_desc vop_rename_desc; +static __inline int VOP_RENAME __P(( + struct vnode *fdvp, + struct vnode *fvp, + struct componentname *fcnp, + struct vnode *tdvp, + struct vnode *tvp, + struct componentname *tcnp)); +static __inline int VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp) + struct vnode *fdvp; + struct vnode *fvp; + struct componentname *fcnp; + struct vnode *tdvp; + struct vnode *tvp; + struct componentname *tcnp; +{ + struct vop_rename_args a; + int rc; + a.a_desc = VDESC(vop_rename); + a.a_fdvp = fdvp; + a.a_fvp = fvp; + a.a_fcnp = fcnp; + a.a_tdvp = tdvp; + a.a_tvp = tvp; + a.a_tcnp = tcnp; + rc = VCALL(fdvp, VOFFSET(vop_rename), &a); + return (rc); +} +struct vop_mkdir_args { + struct vnodeop_desc *a_desc; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; +}; +extern struct vnodeop_desc vop_mkdir_desc; +static __inline int VOP_MKDIR __P(( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp, + struct vattr *vap)); +static __inline int VOP_MKDIR(dvp, vpp, cnp, vap) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; + struct vattr *vap; +{ + struct vop_mkdir_args a; + int rc; + a.a_desc = VDESC(vop_mkdir); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + rc = VCALL(dvp, VOFFSET(vop_mkdir), &a); + return (rc); +} +struct vop_rmdir_args { + struct vnodeop_desc *a_desc; + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; +}; +extern struct vnodeop_desc vop_rmdir_desc; +static __inline int VOP_RMDIR __P(( + struct vnode *dvp, + struct vnode *vp, + struct componentname *cnp)); +static __inline int VOP_RMDIR(dvp, vp, cnp) + struct vnode *dvp; + struct vnode *vp; + struct componentname *cnp; +{ + struct vop_rmdir_args a; + int rc; + a.a_desc = VDESC(vop_rmdir); + a.a_dvp = dvp; + a.a_vp = vp; + a.a_cnp = cnp; + rc = VCALL(dvp, VOFFSET(vop_rmdir), &a); + return (rc); +} +struct vop_symlink_args { + struct vnodeop_desc *a_desc; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + char *a_target; +}; +extern struct vnodeop_desc vop_symlink_desc; +static __inline int VOP_SYMLINK __P(( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp, + struct vattr *vap, + char *target)); +static __inline int VOP_SYMLINK(dvp, vpp, cnp, vap, target) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; + struct vattr *vap; + char *target; +{ + struct vop_symlink_args a; + int rc; + a.a_desc = VDESC(vop_symlink); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + a.a_target = target; + rc = VCALL(dvp, VOFFSET(vop_symlink), &a); + return (rc); +} +struct vop_readdir_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; + int *a_eofflag; + int *a_ncookies; + u_long **a_cookies; +}; +extern struct vnodeop_desc vop_readdir_desc; +static __inline int VOP_READDIR __P(( + struct vnode *vp, + struct uio *uio, + struct ucred *cred, + int *eofflag, + int *ncookies, + u_long **cookies)); +static __inline int VOP_READDIR(vp, uio, cred, eofflag, ncookies, cookies) + struct vnode *vp; + struct uio *uio; + struct ucred *cred; + int *eofflag; + int *ncookies; + u_long **cookies; +{ + struct vop_readdir_args a; + int rc; + a.a_desc = VDESC(vop_readdir); + a.a_vp = vp; + a.a_uio = uio; + a.a_cred = cred; + a.a_eofflag = eofflag; + a.a_ncookies = ncookies; + a.a_cookies = cookies; + rc = VCALL(vp, VOFFSET(vop_readdir), &a); + return (rc); +} +struct vop_readlink_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; +}; +extern struct vnodeop_desc vop_readlink_desc; +static __inline int VOP_READLINK __P(( + struct vnode *vp, + struct uio *uio, + struct ucred *cred)); +static __inline int VOP_READLINK(vp, uio, cred) + struct vnode *vp; + struct uio *uio; + struct ucred *cred; +{ + struct vop_readlink_args a; + int rc; + a.a_desc = VDESC(vop_readlink); + a.a_vp = vp; + a.a_uio = uio; + a.a_cred = cred; + rc = VCALL(vp, VOFFSET(vop_readlink), &a); + return (rc); +} +struct vop_inactive_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_inactive_desc; +static __inline int VOP_INACTIVE __P(( + struct vnode *vp, + struct proc *p)); +static __inline int VOP_INACTIVE(vp, p) + struct vnode *vp; + struct proc *p; +{ + struct vop_inactive_args a; + int rc; + a.a_desc = VDESC(vop_inactive); + a.a_vp = vp; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_inactive), &a); + return (rc); +} +struct vop_reclaim_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_reclaim_desc; +static __inline int VOP_RECLAIM __P(( + struct vnode *vp, + struct proc *p)); +static __inline int VOP_RECLAIM(vp, p) + struct vnode *vp; + struct proc *p; +{ + struct vop_reclaim_args a; + int rc; + a.a_desc = VDESC(vop_reclaim); + a.a_vp = vp; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_reclaim), &a); + return (rc); +} +struct vop_lock_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + int a_flags; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_lock_desc; +static __inline int VOP_LOCK __P(( + struct vnode *vp, + int flags, + struct proc *p)); +static __inline int VOP_LOCK(vp, flags, p) + struct vnode *vp; + int flags; + struct proc *p; +{ + struct vop_lock_args a; + int rc; + a.a_desc = VDESC(vop_lock); + a.a_vp = vp; + a.a_flags = flags; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_lock), &a); + return (rc); +} +struct vop_unlock_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + int a_flags; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_unlock_desc; +static __inline int VOP_UNLOCK __P(( + struct vnode *vp, + int flags, + struct proc *p)); +static __inline int VOP_UNLOCK(vp, flags, p) + struct vnode *vp; + int flags; + struct proc *p; +{ + struct vop_unlock_args a; + int rc; + a.a_desc = VDESC(vop_unlock); + a.a_vp = vp; + a.a_flags = flags; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_unlock), &a); + return (rc); +} +struct vop_bmap_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + daddr_t a_bn; + struct vnode **a_vpp; + daddr_t *a_bnp; + int *a_runp; + int *a_runb; +}; +extern struct vnodeop_desc vop_bmap_desc; +static __inline int VOP_BMAP __P(( + struct vnode *vp, + daddr_t bn, + struct vnode **vpp, + daddr_t *bnp, + int *runp, + int *runb)); +static __inline int VOP_BMAP(vp, bn, vpp, bnp, runp, runb) + struct vnode *vp; + daddr_t bn; + struct vnode **vpp; + daddr_t *bnp; + int *runp; + int *runb; +{ + struct vop_bmap_args a; + int rc; + a.a_desc = VDESC(vop_bmap); + a.a_vp = vp; + a.a_bn = bn; + a.a_vpp = vpp; + a.a_bnp = bnp; + a.a_runp = runp; + a.a_runb = runb; + rc = VCALL(vp, VOFFSET(vop_bmap), &a); + return (rc); +} +struct vop_strategy_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct buf *a_bp; +}; +extern struct vnodeop_desc vop_strategy_desc; +static __inline int VOP_STRATEGY __P(( + struct vnode *vp, + struct buf *bp)); +static __inline int VOP_STRATEGY(vp, bp) + struct vnode *vp; + struct buf *bp; +{ + struct vop_strategy_args a; + int rc; + a.a_desc = VDESC(vop_strategy); + a.a_vp = vp; + a.a_bp = bp; + rc = VCALL(vp, VOFFSET(vop_strategy), &a); + return (rc); +} +struct vop_print_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; +}; +extern struct vnodeop_desc vop_print_desc; +static __inline int VOP_PRINT __P(( + struct vnode *vp)); +static __inline int VOP_PRINT(vp) + struct vnode *vp; +{ + struct vop_print_args a; + int rc; + a.a_desc = VDESC(vop_print); + a.a_vp = vp; + rc = VCALL(vp, VOFFSET(vop_print), &a); + return (rc); +} +struct vop_pathconf_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + int a_name; + register_t *a_retval; +}; +extern struct vnodeop_desc vop_pathconf_desc; +static __inline int VOP_PATHCONF __P(( + struct vnode *vp, + int name, + register_t *retval)); +static __inline int VOP_PATHCONF(vp, name, retval) + struct vnode *vp; + int name; + register_t *retval; +{ + struct vop_pathconf_args a; + int rc; + a.a_desc = VDESC(vop_pathconf); + a.a_vp = vp; + a.a_name = name; + a.a_retval = retval; + rc = VCALL(vp, VOFFSET(vop_pathconf), &a); + return (rc); +} +struct vop_advlock_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + caddr_t a_id; + int a_op; + struct flock *a_fl; + int a_flags; +}; +extern struct vnodeop_desc vop_advlock_desc; +static __inline int VOP_ADVLOCK __P(( + struct vnode *vp, + caddr_t id, + int op, + struct flock *fl, + int flags)); +static __inline int VOP_ADVLOCK(vp, id, op, fl, flags) + struct vnode *vp; + caddr_t id; + int op; + struct flock *fl; + int flags; +{ + struct vop_advlock_args a; + int rc; + a.a_desc = VDESC(vop_advlock); + a.a_vp = vp; + a.a_id = id; + a.a_op = op; + a.a_fl = fl; + a.a_flags = flags; + rc = VCALL(vp, VOFFSET(vop_advlock), &a); + return (rc); +} +struct vop_balloc_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + off_t a_startoffset; + int a_size; + struct ucred *a_cred; + int a_flags; + struct buf **a_bpp; +}; +extern struct vnodeop_desc vop_balloc_desc; +static __inline int VOP_BALLOC __P(( + struct vnode *vp, + off_t startoffset, + int size, + struct ucred *cred, + int flags, + struct buf **bpp)); +static __inline int VOP_BALLOC(vp, startoffset, size, cred, flags, bpp) + struct vnode *vp; + off_t startoffset; + int size; + struct ucred *cred; + int flags; + struct buf **bpp; +{ + struct vop_balloc_args a; + int rc; + a.a_desc = VDESC(vop_balloc); + a.a_vp = vp; + a.a_startoffset = startoffset; + a.a_size = size; + a.a_cred = cred; + a.a_flags = flags; + a.a_bpp = bpp; + rc = VCALL(vp, VOFFSET(vop_balloc), &a); + return (rc); +} +struct vop_reallocblks_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct cluster_save *a_buflist; +}; +extern struct vnodeop_desc vop_reallocblks_desc; +static __inline int VOP_REALLOCBLKS __P(( + struct vnode *vp, + struct cluster_save *buflist)); +static __inline int VOP_REALLOCBLKS(vp, buflist) + struct vnode *vp; + struct cluster_save *buflist; +{ + struct vop_reallocblks_args a; + int rc; + a.a_desc = VDESC(vop_reallocblks); + a.a_vp = vp; + a.a_buflist = buflist; + rc = VCALL(vp, VOFFSET(vop_reallocblks), &a); + return (rc); +} +struct vop_getpages_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + vm_page_t *a_m; + int a_count; + int a_reqpage; + vm_ooffset_t a_offset; +}; +extern struct vnodeop_desc vop_getpages_desc; +static __inline int VOP_GETPAGES __P(( + struct vnode *vp, + vm_page_t *m, + int count, + int reqpage, + vm_ooffset_t offset)); +static __inline int VOP_GETPAGES(vp, m, count, reqpage, offset) + struct vnode *vp; + vm_page_t *m; + int count; + int reqpage; + vm_ooffset_t offset; +{ + struct vop_getpages_args a; + int rc; + a.a_desc = VDESC(vop_getpages); + a.a_vp = vp; + a.a_m = m; + a.a_count = count; + a.a_reqpage = reqpage; + a.a_offset = offset; + rc = VCALL(vp, VOFFSET(vop_getpages), &a); + return (rc); +} +struct vop_putpages_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + vm_page_t *a_m; + int a_count; + int a_sync; + int *a_rtvals; + vm_ooffset_t a_offset; +}; +extern struct vnodeop_desc vop_putpages_desc; +static __inline int VOP_PUTPAGES __P(( + struct vnode *vp, + vm_page_t *m, + int count, + int sync, + int *rtvals, + vm_ooffset_t offset)); +static __inline int VOP_PUTPAGES(vp, m, count, sync, rtvals, offset) + struct vnode *vp; + vm_page_t *m; + int count; + int sync; + int *rtvals; + vm_ooffset_t offset; +{ + struct vop_putpages_args a; + int rc; + a.a_desc = VDESC(vop_putpages); + a.a_vp = vp; + a.a_m = m; + a.a_count = count; + a.a_sync = sync; + a.a_rtvals = rtvals; + a.a_offset = offset; + rc = VCALL(vp, VOFFSET(vop_putpages), &a); + return (rc); +} +struct vop_freeblks_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + daddr_t a_addr; + daddr_t a_length; +}; +extern struct vnodeop_desc vop_freeblks_desc; +static __inline int VOP_FREEBLKS __P(( + struct vnode *vp, + daddr_t addr, + daddr_t length)); +static __inline int VOP_FREEBLKS(vp, addr, length) + struct vnode *vp; + daddr_t addr; + daddr_t length; +{ + struct vop_freeblks_args a; + int rc; + a.a_desc = VDESC(vop_freeblks); + a.a_vp = vp; + a.a_addr = addr; + a.a_length = length; + rc = VCALL(vp, VOFFSET(vop_freeblks), &a); + return (rc); +} +struct vop_bwrite_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct buf *a_bp; +}; +extern struct vnodeop_desc vop_bwrite_desc; +static __inline int VOP_BWRITE __P(( + struct vnode *vp, + struct buf *bp)); +static __inline int VOP_BWRITE(vp, bp) + struct vnode *vp; + struct buf *bp; +{ + struct vop_bwrite_args a; + int rc; + a.a_desc = VDESC(vop_bwrite); + a.a_vp = vp; + a.a_bp = bp; + rc = VCALL(vp, VOFFSET(vop_bwrite), &a); + return (rc); +} +struct vop_getacl_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + acl_type_t a_type; + struct acl *a_aclp; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_getacl_desc; +static __inline int VOP_GETACL __P(( + struct vnode *vp, + acl_type_t type, + struct acl *aclp, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_GETACL(vp, type, aclp, cred, p) + struct vnode *vp; + acl_type_t type; + struct acl *aclp; + struct ucred *cred; + struct proc *p; +{ + struct vop_getacl_args a; + int rc; + a.a_desc = VDESC(vop_getacl); + a.a_vp = vp; + a.a_type = type; + a.a_aclp = aclp; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_getacl), &a); + return (rc); +} +struct vop_setacl_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + acl_type_t a_type; + struct acl *a_aclp; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_setacl_desc; +static __inline int VOP_SETACL __P(( + struct vnode *vp, + acl_type_t type, + struct acl *aclp, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_SETACL(vp, type, aclp, cred, p) + struct vnode *vp; + acl_type_t type; + struct acl *aclp; + struct ucred *cred; + struct proc *p; +{ + struct vop_setacl_args a; + int rc; + a.a_desc = VDESC(vop_setacl); + a.a_vp = vp; + a.a_type = type; + a.a_aclp = aclp; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_setacl), &a); + return (rc); +} +struct vop_aclcheck_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + acl_type_t a_type; + struct acl *a_aclp; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_aclcheck_desc; +static __inline int VOP_ACLCHECK __P(( + struct vnode *vp, + acl_type_t type, + struct acl *aclp, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_ACLCHECK(vp, type, aclp, cred, p) + struct vnode *vp; + acl_type_t type; + struct acl *aclp; + struct ucred *cred; + struct proc *p; +{ + struct vop_aclcheck_args a; + int rc; + a.a_desc = VDESC(vop_aclcheck); + a.a_vp = vp; + a.a_type = type; + a.a_aclp = aclp; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_aclcheck), &a); + return (rc); +} +struct vop_getextattr_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + char *a_name; + struct uio *a_uio; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_getextattr_desc; +static __inline int VOP_GETEXTATTR __P(( + struct vnode *vp, + char *name, + struct uio *uio, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_GETEXTATTR(vp, name, uio, cred, p) + struct vnode *vp; + char *name; + struct uio *uio; + struct ucred *cred; + struct proc *p; +{ + struct vop_getextattr_args a; + int rc; + a.a_desc = VDESC(vop_getextattr); + a.a_vp = vp; + a.a_name = name; + a.a_uio = uio; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_getextattr), &a); + return (rc); +} +struct vop_setextattr_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + char *a_name; + struct uio *a_uio; + struct ucred *a_cred; + struct proc *a_p; +}; +extern struct vnodeop_desc vop_setextattr_desc; +static __inline int VOP_SETEXTATTR __P(( + struct vnode *vp, + char *name, + struct uio *uio, + struct ucred *cred, + struct proc *p)); +static __inline int VOP_SETEXTATTR(vp, name, uio, cred, p) + struct vnode *vp; + char *name; + struct uio *uio; + struct ucred *cred; + struct proc *p; +{ + struct vop_setextattr_args a; + int rc; + a.a_desc = VDESC(vop_setextattr); + a.a_vp = vp; + a.a_name = name; + a.a_uio = uio; + a.a_cred = cred; + a.a_p = p; + rc = VCALL(vp, VOFFSET(vop_setextattr), &a); + return (rc); +} diff --git a/src/afs/Makefile b/src/afs/Makefile index 6a8eb91..efc6126 100644 --- a/src/afs/Makefile +++ b/src/afs/Makefile @@ -33,7 +33,7 @@ kinstall: AFS_component_version_number.c gencat -m afszcm.cat afs_trace.msf ;; \ *_linux* ) \ gencat --new afszcm.cat afs_trace.msf ;; \ - ppc_darwin*) \ + ppc_darwin* | i386_fbsd*) \ echo No gencat for ${SYS_NAME} ;; \ * ) \ gencat afszcm.cat afs_trace.msf ;; \ @@ -59,7 +59,7 @@ install install.noversion: kinstall ukinstall ${INSTALL} longc_procs.h ${DESTDIR}include/afs ;; \ esac case ${SYS_NAME} in \ - next_mach30 | vax_ul43 | ppc_darwin* ) \ + next_mach30 | vax_ul43 | ppc_darwin* | i386_fbsd* ) \ echo skipping afszcm.cat install for ${SYS_NAME} ;; \ * ) \ ${INSTALL} afszcm.cat ${DESTDIR}root.client/usr/vice/etc/C ;; \ diff --git a/src/afs/UKERNEL/afs_usrops.c b/src/afs/UKERNEL/afs_usrops.c index da388ca..2d93e7c 100644 --- a/src/afs/UKERNEL/afs_usrops.c +++ b/src/afs/UKERNEL/afs_usrops.c @@ -1845,7 +1845,7 @@ void uafs_Init( iob.out = tbuffer; iob.out_size = sizeof(tbuffer); -#if defined(AFS_USR_SUN5_ENV) || defined(AFS_USR_OSF_ENV) || defined(AFS_USR_HPUX_ENV) || defined(AFS_USR_LINUX22_ENV) || defined(AFS_USR_DARWIN_ENV) +#if defined(AFS_USR_SUN5_ENV) || defined(AFS_USR_OSF_ENV) || defined(AFS_USR_HPUX_ENV) || defined(AFS_USR_LINUX22_ENV) || defined(AFS_USR_DARWIN_ENV) || defined(AFS_USR_FBSD_ENV) rc = syscall(AFS_SYSCALL, AFSCALL_PIOCTL, 0, _VICEIOCTL(8), &iob, 0); #elif defined(AFS_USR_SGI_ENV) rc = syscall(AFS_PIOCTL, 0, _VICEIOCTL(8), &iob, 0); diff --git a/src/afs/UKERNEL/sysincludes.h b/src/afs/UKERNEL/sysincludes.h index 9c768a0..367b6e2 100644 --- a/src/afs/UKERNEL/sysincludes.h +++ b/src/afs/UKERNEL/sysincludes.h @@ -11,7 +11,7 @@ #define __AFS_SYSINCLUDESH__ 1 #include -#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 #endif #include @@ -114,7 +114,7 @@ #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 @@ -135,7 +135,7 @@ #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) @@ -183,7 +183,7 @@ #undef socket #endif /* AFS_USR_SGI_ENV */ -#ifdef AFS_USR_DARWIN_ENV +#if defined(AFS_USR_DARWIN_ENV) || defined(AFS_USR_FBSD_ENV) #undef if_mtu #undef if_metric #endif @@ -1326,7 +1326,9 @@ struct min_direct { struct usr_ucred { unsigned long cr_ref; long cr_uid; +#if !defined(AFS_USR_FBSD_ENV) long cr_gid; +#endif long cr_ruid; long cr_rgid; long cr_suid; diff --git a/src/afs/VNOPS/afs_vnop_attrs.c b/src/afs/VNOPS/afs_vnop_attrs.c index 87e0913..311f216 100644 --- a/src/afs/VNOPS/afs_vnop_attrs.c +++ b/src/afs/VNOPS/afs_vnop_attrs.c @@ -97,11 +97,11 @@ afs_CopyOutAttrs(avc, attrs) * anyway, so the difference between 512K and 1000000 shouldn't matter * much, and "&" is a lot faster than "%". */ -#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) attrs->va_atime.tv_nsec = attrs->va_mtime.tv_nsec = attrs->va_ctime.tv_nsec = (hgetlo(avc->m.DataVersion) & 0x7ffff) * 1000; -#if defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) attrs->va_blocksize = PAGESIZE; /* XXX Was 8192 XXX */ #else attrs->va_blksize = PAGESIZE; /* XXX Was 8192 XXX */ @@ -137,7 +137,7 @@ afs_CopyOutAttrs(avc, attrs) attrs->va_flags = 0; #endif /* AFS_OSF_ENV */ -#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) #if !defined(AFS_HPUX_ENV) #ifdef AFS_SUN5_ENV attrs->va_nblocks = (attrs->va_size? ((attrs->va_size + 1023)>>10) << 1 : 0); @@ -151,7 +151,7 @@ afs_CopyOutAttrs(avc, attrs) #else /* !defined(AFS_HPUX_ENV) */ attrs->va_blocks = (attrs->va_size? ((attrs->va_size + 1023)>>10) : 0); #endif /* !defined(AFS_HPUX_ENV) */ -#else /* ! AFS_OSF_ENV */ +#else /* ! AFS_OSF_ENV && !AFS_FBSD_ENV */ attrs->va_bytes = (attrs->va_size? (attrs->va_size + 1023) : 1024); #ifdef va_bytes_rsv attrs->va_bytes_rsv = -1; @@ -232,7 +232,7 @@ afs_getattr(OSI_VC_ARG(avc), attrs, acred) return EACCES; } if (avc->mvstat == 2) { -#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) attrs->va_mtime.tv_nsec += ((++avc->xlatordv) * 1000); #else attrs->va_mtime.tv_usec += ++avc->xlatordv; @@ -359,7 +359,7 @@ register struct AFSStoreStatus *as; { #endif mask |= AFS_SETMODTIME; #ifndef AFS_SGI_ENV -#if defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) if (av->va_mtime.tv_nsec == -1) #else if (av->va_mtime.tv_usec == -1) diff --git a/src/afs/VNOPS/afs_vnop_flock.c b/src/afs/VNOPS/afs_vnop_flock.c index 9bebe95..35375b5 100644 --- a/src/afs/VNOPS/afs_vnop_flock.c +++ b/src/afs/VNOPS/afs_vnop_flock.c @@ -40,7 +40,7 @@ void lockIdSet(flock, slp, clid) #if defined(AFS_SUN5_ENV) register proc_t *procp = ttoproc(curthread); #else -#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) #ifdef AFS_SGI_ENV struct proc *procp = OSI_GET_CURRENT_PROCP(); #else @@ -80,7 +80,7 @@ void lockIdSet(flock, slp, clid) #endif slp->pid = clid; #else -#if defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) slp->pid = clid; #else #if defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV) @@ -119,7 +119,7 @@ void lockIdSet(flock, slp, clid) #endif flock->l_pid = clid; #else -#if defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) flock->l_pid = clid; #else #if defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV) @@ -154,7 +154,7 @@ static int lockIdcmp2(flock1, vp, alp, onlymine, clid) #if defined(AFS_SUN5_ENV) register proc_t *procp = ttoproc(curthread); #else -#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) #ifdef AFS_SGI64_ENV struct proc *procp = curprocp; #else /* AFS_SGI64_ENV */ @@ -171,7 +171,7 @@ static int lockIdcmp2(flock1, vp, alp, onlymine, clid) } #endif if ((flock1->l_pid == alp->pid) || -#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) (!onlymine && (flock1->l_pid == getppid())) #else #if defined(AFS_SGI65_ENV) @@ -481,7 +481,7 @@ int flag; pid_t clid; off_t offset; #else -#if defined(AFS_SGI_ENV) || (defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SGI_ENV) || (defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) afs_lockctl(avc, af, acmd, acred, clid) pid_t clid; #else @@ -828,7 +828,7 @@ static int GetFlockCount(struct vcache *avc, struct vrequest *areq) #endif -#if !defined(AFS_AIX_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_SGI_ENV) && !defined(UKERNEL) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_AIX_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_SGI_ENV) && !defined(UKERNEL) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) /* Flock not support on System V systems */ #ifdef AFS_OSF_ENV extern struct fileops afs_fileops; @@ -856,7 +856,11 @@ afs_xflock () { uap = (struct a *)args; getf(&fd, uap->fd, FILE_FLAGS_NULL, &u.u_file_state); #else /* AFS_OSF_ENV */ +#if defined(AFS_FBSD_ENV) uap = (struct a *)u.u_ap; +#else + uap = (struct a *)u.u_ap; +#endif /* AFS_FBSD_ENV */ fd = getf(uap->fd); #endif if (!fd) return; diff --git a/src/afs/VNOPS/afs_vnop_strategy.c b/src/afs/VNOPS/afs_vnop_strategy.c index 48a07ea..aa62ffd 100644 --- a/src/afs/VNOPS/afs_vnop_strategy.c +++ b/src/afs/VNOPS/afs_vnop_strategy.c @@ -25,7 +25,7 @@ -#if defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) afs_ustrategy(abp, credp) struct AFS_UCRED *credp; #else @@ -36,14 +36,14 @@ afs_ustrategy(abp) struct uio tuio; register struct vcache *tvc = (struct vcache *) abp->b_vp; register afs_int32 len = abp->b_bcount; -#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) #ifdef AFS_AIX41_ENV struct ucred *credp; #else struct AFS_UCRED *credp = u.u_cred; #endif #endif -#if defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) int async = abp->b_flags & B_ASYNC; #endif struct iovec tiovec[1]; @@ -71,7 +71,7 @@ afs_ustrategy(abp) */ tuio.afsio_iov = tiovec; tuio.afsio_iovcnt = 1; -#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) || defined(AFS_SUN5_ENV) +#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_FBSD_ENV) tuio.afsio_offset = (u_int) dbtob(abp->b_blkno); #if defined(AFS_SUN5_ENV) tuio._uio_offset._p._u = 0; @@ -84,7 +84,11 @@ afs_ustrategy(abp) tuio.afsio_fmode = 0; #endif tuio.afsio_resid = abp->b_bcount; +#if defined(AFS_FBSD_ENV) + tiovec[0].iov_base = abp->b_saveaddr; +#else tiovec[0].iov_base = abp->b_un.b_addr; +#endif /* AFS_FBSD_ENV */ tiovec[0].iov_len = abp->b_bcount; /* are user's credentials valid here? probably, but this sure seems like the wrong things to do. */ @@ -95,7 +99,11 @@ afs_ustrategy(abp) #endif if (code == 0) { if (tuio.afsio_resid > 0) +#if defined(AFS_FBSD_ENV) + bzero(abp->b_saveaddr + abp->b_bcount - tuio.afsio_resid, tuio.afsio_resid); +#else bzero(abp->b_un.b_addr + abp->b_bcount - tuio.afsio_resid, tuio.afsio_resid); +#endif /* AFS_FBSD_ENV */ #ifdef AFS_AIX32_ENV /* * If we read a block that is past EOF and the user was not storing @@ -140,7 +148,11 @@ afs_ustrategy(abp) len = MIN(abp->b_bcount, ((struct vcache *)abp->b_vp)->m.Length - dbtob(abp->b_blkno)); #endif /* AFS_ALPHA_ENV */ tuio.afsio_resid = len; +#if defined(AFS_FBSD_ENV) + tiovec[0].iov_base = abp->b_saveaddr; +#else tiovec[0].iov_base = abp->b_un.b_addr; +#endif /* AFS_FBSD_ENV */ tiovec[0].iov_len = len; /* are user's credentials valid here? probably, but this sure seems like the wrong things to do. */ diff --git a/src/afs/VNOPS/afs_vnop_write.c b/src/afs/VNOPS/afs_vnop_write.c index 49a3d91..77b56aa 100644 --- a/src/afs/VNOPS/afs_vnop_write.c +++ b/src/afs/VNOPS/afs_vnop_write.c @@ -529,7 +529,7 @@ afs_UFSWrite(avc, auio, aio, acred, noLock) code = osi_file_uio_rdwr(tfile, &tuio, UIO_WRITE); AFS_GLOCK(); #else -#if defined(AFS_DARWIN_ENV) +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) AFS_GUNLOCK(); VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc()); code = VOP_WRITE(tfile->vnode, &tuio, 0, &afs_osi_cred); @@ -537,7 +537,7 @@ afs_UFSWrite(avc, auio, aio, acred, noLock) AFS_GLOCK(); #else code = VOP_RDWR(tfile->vnode, &tuio, UIO_WRITE, 0, &afs_osi_cred); -#endif /* AFS_DARWIN_ENV */ +#endif /* AFS_DARWIN_ENV || AFS_FBSD_ENV */ #endif /* AFS_LINUX20_ENV */ #endif /* AFS_HPUX100_ENV */ #endif /* AFS_OSF_ENV */ @@ -609,7 +609,7 @@ afs_UFSWrite(avc, auio, aio, acred, noLock) * If write is implemented via VM, afs_fsync() is called from the high-level * write op. */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) if (noLock && (aio & IO_SYNC)) { #else #ifdef AFS_HPUX_ENV @@ -650,7 +650,7 @@ struct vrequest *areq; { -#if !defined (AFS_AIX_ENV) && !defined (AFS_HPUX_ENV) && !defined (AFS_SUN5_ENV) && !defined(AFS_SGI_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined (AFS_AIX_ENV) && !defined (AFS_HPUX_ENV) && !defined (AFS_SUN5_ENV) && !defined(AFS_SGI_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) #ifdef AFS_DUX50_ENV #define vno_close(X) vn_close((X), 0, NOCRED) #elif defined(AFS_DUX40_ENV) diff --git a/src/afs/afs.h b/src/afs/afs.h index 352c1cf..4f80931 100644 --- a/src/afs/afs.h +++ b/src/afs/afs.h @@ -509,7 +509,11 @@ struct SimpleLocks { #define VPageCleaning 0x2 /* Solaris - Cache Trunc Daemon sez keep out */ #define CPSIZE 2 +#if !defined(AFS_FBSD_ENV) #define vrefCount v.v_count +#else +#define vrefCount v.v_usecount +#endif /* AFS_FBSD_ENV */ #define AFS_MAXDV 0x7fffffff /* largest dataversion number */ #define AFS_NOTRUNC 0x7fffffff /* largest dataversion number */ diff --git a/src/afs/afs_analyze.c b/src/afs/afs_analyze.c index 32bfc5c..849eb03 100644 --- a/src/afs/afs_analyze.c +++ b/src/afs/afs_analyze.c @@ -15,7 +15,7 @@ #include "../afs/sysincludes.h" /* Standard vendor system headers */ #ifndef UKERNEL -#ifndef AFS_LINUX20_ENV +#if !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV) #include #include #endif @@ -23,7 +23,7 @@ #ifdef AFS_SGI62_ENV #include "../h/hashing.h" #endif -#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) +#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV) #include #endif #endif /* !UKERNEL */ diff --git a/src/afs/afs_call.c b/src/afs/afs_call.c index ec90841..930b294 100644 --- a/src/afs/afs_call.c +++ b/src/afs/afs_call.c @@ -42,7 +42,7 @@ char afs_rootVolumeName[64]=""; struct afs_icl_set *afs_iclSetp = (struct afs_icl_set*)0; struct afs_icl_set *afs_iclLongTermSetp = (struct afs_icl_set*)0; -#if defined(AFS_GLOBAL_SUNLOCK) && !defined(AFS_HPUX_ENV) && !defined(AFS_AIX41_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV) +#if defined(AFS_GLOBAL_SUNLOCK) && !defined(AFS_HPUX_ENV) && !defined(AFS_AIX41_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) kmutex_t afs_global_lock; kmutex_t afs_rxglobal_lock; @@ -57,7 +57,7 @@ simple_lock_data_t afs_global_lock; #elif defined(AFS_DARWIN_ENV) struct lock__bsd__ afs_global_lock; #endif -#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) thread_t afs_global_owner; #endif /* AFS_OSF_ENV */ diff --git a/src/afs/afs_dcache.c b/src/afs/afs_dcache.c index 478d3d8..9c7018f 100644 --- a/src/afs/afs_dcache.c +++ b/src/afs/afs_dcache.c @@ -1237,7 +1237,7 @@ static int afs_UFSCacheStoreProc(acall, afile, alen, avc, shouldWake, tlen = (alen > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : alen); got = afs_osi_Read(afile, -1, tbuffer, tlen); if ((got < 0) -#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) || (got != tlen && getuerror()) #endif ) { @@ -2300,7 +2300,7 @@ struct dcache *afs_UFSGetDSlot(aslot, tmpdc) tdc->f.chunk = -1; hones(tdc->f.versionNo); tdc->flags |= DFEntryMod; -#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) last_error = getuerror(); #endif lasterrtime = osi_Time(); diff --git a/src/afs/afs_init.c b/src/afs/afs_init.c index 00f38a5..9cfb261 100644 --- a/src/afs/afs_init.c +++ b/src/afs/afs_init.c @@ -432,11 +432,11 @@ afs_InitCacheInfo(afile) TO_KERNEL_SPACE(); } #else -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) if (!VFS_STATFS(filevp->v_mount, &st, current_proc())) #else if (!VFS_STATFS(filevp->v_vfsp, &st)) -#endif /* AFS_DARWIN_ENV */ +#endif /* AFS_DARWIN_ENV || AFS_FBSD_ENV */ #endif /* AFS_LINUX20_ENV */ #endif /* AIX41 */ #endif /* OSF */ diff --git a/src/afs/afs_osi.c b/src/afs/afs_osi.c index e987925..e36f9b8 100644 --- a/src/afs/afs_osi.c +++ b/src/afs/afs_osi.c @@ -50,7 +50,7 @@ void osi_Init() #elif defined(AFS_OSF_ENV) usimple_lock_init(&afs_global_lock); afs_global_owner = (thread_t)0; -#elif defined(AFS_DARWIN_ENV) +#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) lockinit(&afs_global_lock, PLOCK, "afs global lock", 0, 0); afs_global_owner = (thread_t)0; #elif defined(AFS_AIX41_ENV) @@ -80,7 +80,7 @@ void osi_Init() osi_Active(avc) register struct vcache *avc; { AFS_STATCNT(osi_Active); -#if defined(AFS_SUN_ENV) || defined(AFS_AIX_ENV) || defined(AFS_OSF_ENV) || defined(AFS_SUN5_ENV) || (AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SUN_ENV) || defined(AFS_AIX_ENV) || defined(AFS_OSF_ENV) || defined(AFS_SUN5_ENV) || (AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) if ((avc->opens > 0) || (avc->states & CMAPPED)) return 1; /* XXX: Warning, verify this XXX */ #else #if defined(AFS_MACH_ENV) @@ -295,7 +295,7 @@ void afs_osi_Invisible() { #if defined(AFS_HPUX101_ENV) set_system_proc(u.u_procp); #else -#if defined(AFS_DARWIN_ENV) +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) current_proc()->p_flag |= P_SYSTEM; #else #if !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) @@ -351,7 +351,7 @@ afs_osi_SetTime(atv) stime(&sta); AFS_GLOCK(); #else -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) AFS_GUNLOCK(); setthetime(atv); AFS_GLOCK(); @@ -379,7 +379,7 @@ afs_osi_SetTime(atv) #ifdef AFS_AUX_ENV logtchg(atv->tv_sec); #endif -#endif /* AFS_DARWIN_ENV */ +#endif /* AFS_DARWIN_ENV || AFS_FBSD_ENV */ #endif /* AFS_SGI_ENV */ #endif /* AFS_SUN55_ENV */ #endif /* AFS_SUN5_ENV */ @@ -742,7 +742,7 @@ extern int npid; } #endif -#if defined(AFS_DARWIN_ENV) +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) void afs_osi_TraverseProcTable() { struct proc *p; @@ -914,7 +914,7 @@ const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pr) return rv; } -#elif defined(AFS_DARWIN_ENV) +#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pr) { struct AFS_UCRED *rv=NULL; diff --git a/src/afs/afs_osi.h b/src/afs/afs_osi.h index bae946e..54063e6 100644 --- a/src/afs/afs_osi.h +++ b/src/afs/afs_osi.h @@ -109,7 +109,7 @@ extern void osi_FreeLargeSpace(void *x); /* * Vnode related macros */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) extern int (**afs_vnodeop_p)(); #define IsAfsVnode(vc) ((vc)->v_op == afs_vnodeop_p) #define SetAfsVnode(vc) (vc)->v_op = afs_vnodeop_p @@ -236,7 +236,7 @@ typedef struct timeval osi_timeval_t; * (Also, of course, the vnode is assumed to be one of ours. Can't use this * macro for V-file vnodes.) */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) /* Bare refcount manipulation would probably work on this platform, but just calling VREF does not */ #define AFS_FAST_HOLD(vp) osi_vnhold((vp),0) @@ -282,7 +282,7 @@ typedef struct timeval osi_timeval_t; AFS_GLOCK(); \ } while(0) -#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE) \ do { \ int haveGlock = ISAFS_GLOCK(); \ @@ -293,7 +293,7 @@ typedef struct timeval osi_timeval_t; if (haveGlock) \ AFS_GLOCK(); \ } while(0) -#else /* AFS_OSF_ENV */ +#else /* AFS_OSF_ENV || AFS_FBSD_ENV */ #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE) \ do { \ int haveGlock = ISAFS_GLOCK(); \ @@ -303,7 +303,7 @@ typedef struct timeval osi_timeval_t; if (haveGlock) \ AFS_GLOCK(); \ } while(0) -#endif /* AFS_OSF_ENV */ +#endif /* AFS_OSF_ENV || AFS_FBSD_ENV */ #else /* AFS_GLOBAL_SUNLOCK */ @@ -322,18 +322,18 @@ typedef struct timeval osi_timeval_t; CODE = copyout((SRC),(DST),(LEN)); \ } while(0) -#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE) \ do { \ (UIO)->uio_rw = (RW); \ CODE = uiomove((SRC),(LEN),(UIO)); \ } while(0) -#else /* AFS_OSF_ENV */ +#else /* AFS_OSF_ENV || AFS_FBSD_ENV */ #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE) \ do { \ CODE = uiomove((SRC),(LEN),(RW),(UIO)); \ } while(0) -#endif /* AFS_OSF_ENV */ +#endif /* AFS_OSF_ENV || AFS_FBSD_ENV */ #endif /* AFS_GLOBAL_SUNLOCK */ diff --git a/src/afs/afs_osi_pag.c b/src/afs/afs_osi_pag.c index 354adcc..a1b6cec 100644 --- a/src/afs/afs_osi_pag.c +++ b/src/afs/afs_osi_pag.c @@ -100,7 +100,7 @@ afs_uint32 getpag(void) { int #if defined(AFS_SUN5_ENV) afs_setpag (struct AFS_UCRED **credpp) -#elif defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#elif defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) afs_setpag (struct proc *p, void *args, int *retval) #else afs_setpag (void) @@ -127,7 +127,7 @@ afs_setpag (void) #if defined(AFS_SUN5_ENV) code = AddPag(genpag(), credpp); -#elif defined(AFS_OSF_ENV) +#elif defined(AFS_OSF_ENV) || defined(AFS_FBSD_ENV) code = AddPag(p, genpag(), &p->p_rcred); #elif defined(AFS_AIX41_ENV) { @@ -159,7 +159,7 @@ afs_setpag (void) code = AddPag(genpag(), &credp); crfree(credp); } -#elif defined(AFS_DARWIN_ENV) +#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) { struct ucred *credp=crdup(p->p_cred->pc_ucred); code=AddPag(p, genpag(), &credp); @@ -170,7 +170,7 @@ afs_setpag (void) #endif afs_Trace1(afs_iclSetp, CM_TRACE_SETPAG, ICL_TYPE_INT32, code); -#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #if defined(AFS_SGI53_ENV) && defined(MP) AFS_GUNLOCK(); #endif /* defined(AFS_SGI53_ENV) && defined(MP) */ @@ -182,20 +182,20 @@ afs_setpag (void) #endif } -#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) int AddPag(struct proc *p, afs_int32 aval, struct AFS_UCRED **credpp) -#else /* AFS_OSF_ENV */ +#else /* AFS_OSF_ENV || AFS_FBSD_ENV */ int AddPag(afs_int32 aval, struct AFS_UCRED **credpp) #endif { afs_int32 newpag, code; AFS_STATCNT(AddPag); -#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) if (code = setpag(p, credpp, aval, &newpag, 0)) #else /* AFS_OSF_ENV */ if (code = setpag(credpp, aval, &newpag, 0)) #endif -#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) return (code); #else return (setuerror(code), code); @@ -217,7 +217,7 @@ afs_InitReq(av, acred) * think it's ok to use the real uid to make setuid * programs (without setpag) to work properly. */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) av->uid = acred->cr_uid; /* default when no pag is set */ /* bsd creds don't have ruid */ #else @@ -279,7 +279,7 @@ afs_int32 PagInCred(const struct AFS_UCRED *cred) if (cred == NULL) { return NOPAG; } -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) if (cred == NOCRED || cred == FSCRED) { return NOPAG; } @@ -293,7 +293,7 @@ afs_int32 PagInCred(const struct AFS_UCRED *cred) return NOPAG; } #else -#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DUX40_ENV) || defined(AFS_LINUX_ENV) +#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DUX40_ENV) || defined(AFS_LINUX_ENV) || defined(AFS_FBSD_ENV) if (cred->cr_ngroups < 2) return NOPAG; #endif #endif diff --git a/src/afs/afs_prototypes.h b/src/afs/afs_prototypes.h index 109487f..bd100ab 100644 --- a/src/afs/afs_prototypes.h +++ b/src/afs/afs_prototypes.h @@ -38,9 +38,9 @@ extern void afs_osi_TraverseProcTable(void); /* afs_osi_pag.c */ extern afs_uint32 genpag(void); extern afs_uint32 getpag(void); -#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) extern int AddPag(struct proc *p, afs_int32 aval, struct AFS_UCRED **credpp); -#else /* AFS_OSF_ENV */ +#else /* AFS_OSF_ENV || AFS_FBSD_ENV */ extern int AddPag(afs_int32 aval, struct AFS_UCRED **credpp); #endif extern afs_uint32 afs_get_pag_from_groups(gid_t g0, gid_t g1); @@ -119,7 +119,7 @@ extern void InstallUVolumeEntry(struct volume *av, struct uvldbentry *ve, int acell, struct cell *tcell, struct vrequest *areq); extern void afs_ResetVolumeInfo(struct volume *tv); -#if defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_AIX_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_AIX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include "../afs/osi_prototypes.h" #endif diff --git a/src/afs/afs_server.c b/src/afs/afs_server.c index 62bbfc7..e8dfc7f 100644 --- a/src/afs/afs_server.c +++ b/src/afs/afs_server.c @@ -1202,7 +1202,7 @@ static afs_SetServerPrefs(sa) #ifdef AFS_SGI62_ENV (void) hash_enum(&hashinfo_inaddr, afsi_enum_set_rank, HTF_INET, NULL, (caddr_t)sa, NULL); -#elif defined(AFS_DARWIN_ENV) +#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) { struct in_ifaddr *ifa; TAILQ_FOREACH(ifa , &in_ifaddrhead, ia_link) { diff --git a/src/afs/afs_user.c b/src/afs/afs_user.c index b1f61fd..3c2a5d5 100644 --- a/src/afs/afs_user.c +++ b/src/afs/afs_user.c @@ -606,7 +606,7 @@ void afs_GCPAGs_perproc_func(AFS_PROC *pproc) afs_GCPAGs_cred_count++; pag = PagInCred(pcred); -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD40_ENV) uid = (pag != NOPAG ? pag : pcred->cr_uid); #else uid = (pag != NOPAG ? pag : pcred->cr_ruid); diff --git a/src/afs/afsincludes.h b/src/afs/afsincludes.h index 0fb0d85..834b45f 100644 --- a/src/afs/afsincludes.h +++ b/src/afs/afsincludes.h @@ -51,6 +51,6 @@ #include "../afs/afs_axscache.h" #include "../afs/icl.h" #include "../afs/afs_prototypes.h" -#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include "../afs/osi_machdep.h" #endif diff --git a/src/afs/exporter.h b/src/afs/exporter.h index 30487e9..fa3745c 100644 --- a/src/afs/exporter.h +++ b/src/afs/exporter.h @@ -39,7 +39,7 @@ #define AFS_XLATOR_MAGIC 0x87654321 #endif -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #define AFS_NFSXLATORREQ(cred) 0 #else #ifdef AFS_OSF_ENV diff --git a/src/afs/lock.h b/src/afs/lock.h index 866b806..4318a66 100644 --- a/src/afs/lock.h +++ b/src/afs/lock.h @@ -109,7 +109,7 @@ extern tid_t thread_self(); #ifdef AFS_LINUX20_ENV #define MyPidxx current->pid #else -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #define MyPidxx (current_proc()->p_pid ) #else #define MyPidxx (u.u_procp->p_pid ) diff --git a/src/afs/sysincludes.h b/src/afs/sysincludes.h index 2899851..0475ced 100644 --- a/src/afs/sysincludes.h +++ b/src/afs/sysincludes.h @@ -41,7 +41,7 @@ struct xfs_inode_info {}; #include #else /* AFS_LINUX22_ENV */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #define _MACH_ETAP_H_ typedef unsigned short etap_event_t; #endif @@ -132,7 +132,7 @@ typedef unsigned short etap_event_t; #include "../h/socketvar.h" #include "../h/protosw.h" -#if defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) +#if defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_FBSD_ENV) # include "../h/dirent.h" # ifdef AFS_SUN5_ENV # include "../h/sysmacros.h" @@ -184,15 +184,24 @@ struct vfspage; /* for vnode.h compiler warnings */ # include "../h/swap.h" /* for struct swpdbd, for vnode.h compiler warnings */ # include "../h/dbd.h" /* for union idbd, for vnode.h compiler warnings */ # endif /* AFS_HPUX_ENV */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD40_ENV) # include # include # include # include # include +#ifndef AFS_FBSD_ENV # include #define timeout_fcn_t mach_timeout_fcn_t # include +#else +# include +# include +# include +# include +# include +# include +#endif #undef timeout_fcn_t #define _DIR_H_ #define doff_t int32_t @@ -213,7 +222,7 @@ struct vfspage; /* for vnode.h compiler warnings */ # endif /* !AFS_HPUX_ENV */ # endif /* !AFS_AIX32_ENV */ # endif /* AFS_SUN5_ENV */ -#endif /* AFS_DARWIN_ENV */ +#endif /* AFS_DARWIN_ENV || AFS_FBSD_ENV */ #endif /* AFS_DEC_ENV */ /* These mainly deal with networking and rpc headers */ @@ -234,7 +243,9 @@ struct vfspage; /* for vnode.h compiler warnings */ /* Miscellaneous headers */ #include "../h/proc.h" +#if !defined(AFS_FBSD_ENV) #include "../h/ioctl.h" +#endif /* AFS_FBSD_ENV */ #if defined(AFS_HPUX101_ENV) #include "../h/proc_iface.h" @@ -246,7 +257,7 @@ struct vfspage; /* for vnode.h compiler warnings */ #include "../h/tty.h" #endif -#if !defined(AFS_SGI_ENV) && !defined(AFS_SUN_ENV) && !defined(AFS_MACH_ENV) && !defined(AFS_AIX32_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_SGI_ENV) && !defined(AFS_SUN_ENV) && !defined(AFS_MACH_ENV) && !defined(AFS_AIX32_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) # include "../h/text.h" #endif diff --git a/src/afsd/Makefile b/src/afsd/Makefile index 2e94d08..6dd79b0 100644 --- a/src/afsd/Makefile +++ b/src/afsd/Makefile @@ -106,6 +106,9 @@ install: all ${INSTALL} -f afs.ppc_darwin.plist ${DESTDIR}root.client/usr/vice/etc/afs.kext/Contents/Info.plist ; \ ${INSTALLex} -f afs.rc.darwin ${DESTDIR}root.client/usr/vice/etc/afs.rc ; \ ${INSTALL} -f afs.rc.darwin.plist ${DESTDIR}root.client/usr/vice/etc/StartupParameters.plist ;; \ + *fbsd*) \ + mkdir -p ${DESTDIR}root.client/usr/vice/etc/afs.rc; \ + ${INSTALL} -f afs.rc.fbsd ${DESTDIR}root.client/usr/vice/etc/afs.rc.fbsd ;; \ * ) \ echo No rc scripts installed for ${SYS_NAME} ;; \ esac diff --git a/src/afsd/afs.rc.fbsd b/src/afsd/afs.rc.fbsd new file mode 100644 index 0000000..c261fc9 --- /dev/null +++ b/src/afsd/afs.rc.fbsd @@ -0,0 +1,123 @@ +#!/bin/sh +# Copyright 2000, International Business Machines Corporation and others. +# All Rights Reserved. +# +# This software has been released under the terms of the IBM Public +# License. For details, see the LICENSE file in the top-level source +# directory or online at http://www.openafs.org/dl/license10.html + +. /etc/rc.common + +CheckForNetwork + +if [ "${NETWORKUP}" = "-NO-" ]; then exit; fi + +if [ -r /var/db/openafs ]; then + VICEETC=/var/db/openafs/etc + AFSD=/usr/sbin/afsd +else + VICEETC=/usr/vice/etc + AFSD=$VICEETC/afsd +fi +CONFIG=$VICEETC/config +AFSDOPT=$CONFIG/afsd.options +PACKAGE=$CONFIG/package.options + +LARGE="-stat 2800 -dcache 2400 -daemons 5 -volumes 128" +MEDIUM="-stat 2000 -dcache 800 -daemons 3 -volumes 70" +SMALL="-stat 300 -dcache 100 -daemons 2 -volumes 50" + +if [ -f $AFSDOPT ]; then + OPTIONS=`cat $AFSDOPT` +else + OPTIONS=$MEDIUM +fi + +# Need the commands ps, awk, kill, sleep +PATH=${PATH}${PATH:+:}/sbin:/bin:/usr/bin +if kmodstat | grep -q openafs ; then +: +else +if [ -d $VICEETC/afs.ko ]; then + echo "Loading AFS kernel extensions" + kldload $VICEETC/afs.ko +else + echo "$VICEETC/afs.ko does not exist. Skipping AFS startup." + exit 1 +fi +fi +if kldstat | grep -q openafs ; then +: +else + echo "AFS kernel extensions failed to initialize. Skipping AFS startup." +fi + +# +# Start the AFS server processes if a bosserver exists +# + +if [ -x /usr/afs/bin/bosserver ]; then + echo "Starting AFS Server processes" + /usr/afs/bin/bosserver + OPTIONS="$OPTIONS -nosettime" + sleep 30 +fi + +# +# Check that all of the client configuration files exist +# + +for file in $AFSD $VICEETC/cacheinfo \ + $VICEETC/ThisCell $VICEETC/CellServDB +do + if [ ! -f ${file} ]; then + echo "${file} does not exist. Not starting AFS client." + exit 1 + fi +done + +# +# Check that the root directory for AFS (/afs) +# and the cache directory (/usr/vice/cache) both exist +# + +for dir in `awk -F: '{print $1, $2}' $VICEETC/cacheinfo` +do + if [ ! -d ${dir} ]; then + echo "${dir} does not exist. Not starting AFS client." + exit 2 + fi +done + +echo "Starting afsd" +$AFSD $OPTIONS + +# +# Run package to update the disk +# +if [ -f /usr/afsws/etc/package -a -f $PACKAGE ]; then + /usr/afsws/etc/package -v -o `cat $PACKAGE` > /dev/console 2>&1 +case $? in +0) + (echo "Package completed successfully") > /dev/console 2>&1 + date > /dev/console 2>&1 + ;; +4) + (echo "Rebooting to restart system") > /dev/console 2>&1 + sync + /sbin/reboot + ;; +*) + (echo "Package update failed; continuing") > /dev/console 2>&1 + ;; +esac + +fi + +# +# Start AFS inetd services +# (See the AFS Command Ref. for notes on the proper configuration of inetd.afs) +# +if [ -f /usr/sbin/inetd.afs -a -f /etc/inetd.conf.afs ]; then + /usr/sbin/inetd.afs /etc/inetd.conf.afs +fi diff --git a/src/afsd/afsd.c b/src/afsd/afsd.c index a3459f9..bf4b9aa 100644 --- a/src/afsd/afsd.c +++ b/src/afsd/afsd.c @@ -93,7 +93,7 @@ #endif #endif -#if defined(AFS_OSF_ENV) || defined(AFS_DEC_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_OSF_ENV) || defined(AFS_DEC_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include #else #include @@ -132,7 +132,7 @@ void set_staticaddrs(void); #if AFS_HAVE_STATVFS #include #else -#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) #include #endif #endif @@ -1343,6 +1343,9 @@ mainproc(as, arock) #ifdef AFS_DEC_ENV if ((mount("AFS",cacheMountDir,mountFlags,GT_AFS,(caddr_t) 0)) < 0) { #else +#ifdef AFS_FBSD_ENV + if ((mount("AFS",cacheMountDir,mountFlags,(caddr_t) 0)) < 0) { +#else #ifdef AFS_AUX_ENV if ((fsmount(MOUNT_AFS,cacheMountDir,mountFlags,(caddr_t) 0)) < 0) { #else @@ -1380,7 +1383,6 @@ mainproc(as, arock) #else #if defined(AFS_SGI_ENV) mountFlags = MS_FSS; - if ((mount(MOUNT_AFS,cacheMountDir,mountFlags,(caddr_t) MOUNT_AFS)) < 0) { #else #ifdef AFS_LINUX20_ENV @@ -1395,6 +1397,7 @@ mainproc(as, arock) #endif /* AFS_HPUX_ENV */ #endif /* AFS_AIX_ENV */ #endif /* AFS_AUX_ENV */ +#endif /* AFS_FBSD_ENV */ #endif /* AFS_DEC_ENV */ printf("%s: Can't mount AFS on %s(%d)\n", rn, cacheMountDir, errno); diff --git a/src/afsmonitor/afsmonitor.c b/src/afsmonitor/afsmonitor.c index 7d62124..89d9c2c 100644 --- a/src/afsmonitor/afsmonitor.c +++ b/src/afsmonitor/afsmonitor.c @@ -1722,7 +1722,7 @@ int a_newProbeCycle; /* start of a new probe cycle ? */ } /* copy connection information */ -#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) bcopy(&(xstat_fs_Results.connP->skt), &(tmp_fsPR->connP->skt), sizeof(struct sockaddr_in)); #else @@ -2454,7 +2454,7 @@ int a_newProbeCycle; /* start of new probe cycle ? */ /* copy connection information */ -#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) bcopy(&(xstat_cm_Results.connP->skt), &(tmp_cmPR->connP->skt), sizeof(struct sockaddr_in)); #else diff --git a/src/config/Makefile.i386_fbsd_42 b/src/config/Makefile.i386_fbsd_42 new file mode 100644 index 0000000..942d7c7 --- /dev/null +++ b/src/config/Makefile.i386_fbsd_42 @@ -0,0 +1,52 @@ +# Copyright 1998 Transarc Corporation +# +# Keep macros within each section in sorted order for clean diff displays. +# +# AFS_OSTYPE used to indicate suffixes and os specific subdirectories. +AFS_OSTYPE = FBSD +# Pointers to destination and source directories +DESTDIR=DEST/ +SRCDIR=DEST/ +# Base directory for linux kernel source. Actually a prefix which is complete +# when LINUX_VERS is appended to it. +# LINUX_SRCDIR = /usr/src/linux- +# Default list of Linux kernels to build. Build will run only if all +# can be built. To build a different set, specify LINUX_VERS to make. +# LINUX_VERS = 2.2.5-15 2.2.10 2.2.12 2.2.12-20 2.2.13 2.2.14 + +# +# compilation and link editor flags +DBG=-g +OPTMZ=-O2 +PAM_CFLAGS = -O2 -pipe -fPIC +# Put -O2 here to _ensure_ all Makefiles pick it up. +XCFLAGS= -O2 -pipe +MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS} +XLDFLAGS= +SHARE_LDFLAGS = -shared -Xlinker -x +SHLIB_SUFFIX=so +SHLIB_CFLAGS= +# +# libraries +MTLIBS=-pthread +TXLIBS= /usr/lib/libncurses.so +XLIBS=-lcompat +# +# programs +AR=ar +AS=as +CP=cp +INSTALL=${SRCDIR}bin/install +LD=ld +MT_CC=cc +MV=mv +RANLIB=ranlib +RM=rm +WASHTOOL=${SRCDIR}bin/washtool +# +# Other OS specific requirements +# +YACC = bison -y +LEX = flex -l +# Used in des library. +CRYPT_OBJ = crypt.o diff --git a/src/config/afs_sysnames.h b/src/config/afs_sysnames.h index ad80007..0b4ebec 100644 --- a/src/config/afs_sysnames.h +++ b/src/config/afs_sysnames.h @@ -131,6 +131,7 @@ #define SYS_NAME_ID_alpha_linux_22 2001 #define SYS_NAME_ID_alpha_linux_24 2002 +#define SYS_NAME_ID_i386_fbsd_42 2100 /* * Placeholder to keep system-wide standard flags since this file is included by all diff --git a/src/config/param.i386_fbsd_42.h b/src/config/param.i386_fbsd_42.h new file mode 100644 index 0000000..217c58a --- /dev/null +++ b/src/config/param.i386_fbsd_42.h @@ -0,0 +1,136 @@ +#ifndef _PARAM_FBSD_42_H_ +#define _PARAM_FBSD_42_H_ + +#include + +#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 + +#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 +#if BYTE_ORDER == BIG_ENDIAN +#define AFSBIG_ENDIAN 1 +#else +#if BYTE_ORDER == LITTLE_ENDIAN +#define AFSLITTLE_ENDIAN 1 +#else +#error machine/endian.h must define BYTE_ORDER! +#endif +#endif +#endif /* ! ASSEMBLER && ! __LANGUAGE_ASSEMBLY__ */ + +#define NEARINODE_HINT 1 /* hint to ufs module to scatter inodes on disk*/ +#define nearInodeHash(volid, hval) { \ + unsigned char* ts = (unsigned char*)&(volid);\ + for ((hval)=0; ts<(unsigned char*)&(volid)+sizeof(volid);ts++){\ + (hval) *= 173; \ + (hval) += *ts; \ + } \ + } + +/* Extra kernel definitions (from kdefs file) */ +#ifdef _KERNEL +#define AFS_GLOBAL_SUNLOCK 1 +#define AFS_VFS34 1 /* What is VFS34??? */ +#define AFS_SHORTGID 1 /* are group id's short? */ +#define afsio_iov uio_iov +#define afsio_iovcnt uio_iovcnt +#define afsio_offset uio_offset +#define afsio_seg uio_segflg +#define afsio_resid uio_resid +#define AFS_UIOSYS UIO_SYSSPACE +#define AFS_UIOUSER UIO_USERSPACE +#define AFS_CLBYTES CLBYTES +#define osi_GetTime(x) microtime(x) +#define AFS_KALLOC(x) kalloc(x) +#define AFS_KFREE(x,y) kfree(x,y) +#define v_count v_usecount +#define v_vfsp v_mount +#define vfs_bsize mnt_stat.f_bsize +#define vfs_fsid mnt_stat.f_fsid +#define va_nodeid va_fileid +#define vfs_vnodecovered mnt_vnodecovered +#define direct dirent +#define vnode_t struct vnode + +#ifndef MUTEX_DEFAULT +#define MUTEX_DEFAULT 0 +#endif /* MUTEX_DEFAULT */ + +#ifndef SSYS +#define SSYS 0x00002 +#endif /* SSYS */ + +#define p_rcred p_ucred + +#define VN_RELE(vp) vrele(((struct vnode *)(vp))) +#define VN_HOLD(vp) VREF(((struct vnode *)(vp))) + +#if !defined(ASSEMBLER) && !defined(__LANGUAGE_ASSEMBLY__) +enum vcexcl {NONEXCL, EXCL}; + +#ifdef KERNEL +#ifndef MIN +#define MIN(A,B) ((A) < (B) ? (A) : (B)) +#endif +#ifndef MAX +#define MAX(A,B) ((A) > (B) ? (A) : (B)) +#endif +#endif /* KERNEL */ + +#endif /* ! ASSEMBLER & ! __LANGUAGE_ASSEMBLY__ */ +#endif /* _KERNEL */ + +#endif /* _PARAM_FBSD_42_H_ */ diff --git a/src/config/param.i386_fbsd_42_usr.h b/src/config/param.i386_fbsd_42_usr.h new file mode 100644 index 0000000..184418b --- /dev/null +++ b/src/config/param.i386_fbsd_42_usr.h @@ -0,0 +1,61 @@ +#ifndef _PARAM_USR_I386_FBSD_42_H_ +#define _PARAM_USR_I386_FBSD_42_H_ + + +#define UKERNEL 1 /* user space kernel */ +#define AFS_ENV 1 +#define AFS_VFSINCL_ENV 1 +#define AFS_USR_FBSD40_ENV 1 +#define AFS_USR_FBSD42_ENV 1 +#define AFS_USR_FBSD_ENV 1 +#define AFS_NONFSTRANS 1 +#define AFS_KERBEROS_ENV + +#define O_SYNC O_FSYNC + +#define AFS_MOUNT_AFS "afs" /* The name of the filesystem type. */ +#define AFS_SYSCALL 210 +#define AFS_64BIT_IOPS_ENV 1 +#define AFS_NAMEI_ENV 1 /* User space interface to file system */ +#include + +#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 +#include +#include +#include +#include +#include +#include +#include + +#endif /* _PARAM_USR_I386_FBSD_42_H_ */ diff --git a/src/des/read_pssword.c b/src/des/read_pssword.c index e081722..ef61944 100644 --- a/src/des/read_pssword.c +++ b/src/des/read_pssword.c @@ -28,12 +28,15 @@ #ifdef AFS_SUN5_ENV #define BSD_COMP #endif +#if defined(AFS_FBSD_ENV) +#define USE_OLD_TTY +#endif #include #include #include #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 #endif @@ -48,7 +51,7 @@ static int intrupt; #include #endif -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include #endif #ifdef AFS_NT40_ENV @@ -102,7 +105,7 @@ lose: return ok; } -#if defined (AFS_AIX_ENV) || defined (AFS_HPUX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) +#if defined (AFS_AIX_ENV) || defined (AFS_HPUX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) static void catch(int); #endif @@ -124,7 +127,7 @@ des_read_pw_string(s,maxa,prompt,verify) { int ok = 0, cnt1=0; char *ptr; -#if defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) register int fno; struct sigaction newsig, oldsig; struct termios save_ttyb, ttyb; @@ -162,7 +165,7 @@ des_read_pw_string(s,maxa,prompt,verify) return -1; } -#if defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) if ((fi = fopen("/dev/tty", "r")) == NULL) return -1; setbuf(fi, (char *)NULL); /* We don't want any buffering for our i/o. */ @@ -388,7 +391,7 @@ sig_restore() #endif -#if defined (AFS_AIX_ENV) || defined (AFS_HPUX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) +#if defined (AFS_AIX_ENV) || defined (AFS_HPUX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) static void catch(int junk) { diff --git a/src/dir/dir.c b/src/dir/dir.c index df9fb35..8ea21dd 100644 --- a/src/dir/dir.c +++ b/src/dir/dir.c @@ -20,7 +20,7 @@ #include "../h/errno.h" #endif #include "../h/time.h" -#if defined(AFS_AIX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV) +#if defined(AFS_AIX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_FBSD_ENV) #include "../h/errno.h" #else #if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV) @@ -31,6 +31,13 @@ #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" diff --git a/src/kauth/kaserver.c b/src/kauth/kaserver.c index 3de02c9..f0f9626 100644 --- a/src/kauth/kaserver.c +++ b/src/kauth/kaserver.c @@ -63,7 +63,7 @@ int MinHours = 0; int npwSums = KA_NPWSUMS; /* needs to be variable sometime */ #include -#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 diff --git a/src/kauth/klogin.c b/src/kauth/klogin.c index 85e1b55..95ecbfa 100644 --- a/src/kauth/klogin.c +++ b/src/kauth/klogin.c @@ -29,7 +29,7 @@ static char sccsid[] = "@(#)login.c 5.15 (Berkeley) 4/12/86"; * login -h hostname (for telnetd, etc.) */ #include -#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 #define quota(a,b,c,d) 0 diff --git a/src/kauth/user.c b/src/kauth/user.c index b2a822a..23fd0cc 100644 --- a/src/kauth/user.c +++ b/src/kauth/user.c @@ -179,7 +179,7 @@ afs_int32 ka_UserAuthenticateGeneral ( } #endif -#if !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_USR_LINUX20_ENV) +#if !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_USR_LINUX20_ENV) && !defined(AFS_FBSD_ENV) /* handle smoothly the case where no AFS system calls exists (yet) */ old = (int (*)())signal(SIGSYS, SIG_IGN); #endif diff --git a/src/libafs/MakefileProto.FBSD b/src/libafs/MakefileProto.FBSD new file mode 100644 index 0000000..07759f6 --- /dev/null +++ b/src/libafs/MakefileProto.FBSD @@ -0,0 +1,112 @@ +#/* Copyright (C) 1995, 1989 Transarc Corporation - All rights reserved */ +# +# MakefileProto for Digital Unix systems +# + +DESTDIR=DEST/ +# include $(DESTDIR)/../obj/config/Makefile.${SYS_NAME} + + +# OS specific object files: +AFS_OS_OBJS = \ + osi_groups.o \ + osi_file.o \ + osi_inode.o \ + osi_misc.o \ + osi_sleep.o \ + osi_vm.o \ + osi_vnodeops.o + +AFS_OS_NFSOBJS = \ + osi_vfsops_nfs.o + +AFS_OS_NONFSOBJS = \ + osi_vfsops.o + + +# System specific build commands and flags +# KDEFS=-DLANGUAGE_C -I/usr/sys/include -I../include \ +# -I/usr/src/sys/${HEADER_RT} -I/usr/src/sys/sys \ +# -DSWAPTYPE=1 -DUERF -DOSF -DCOMPAT_43 -DUFS \ +# -DRT -DKERNEL -D_KERNEL +KDEFS=-Wall -fformat-extensions -ansi -nostdinc -I/usr/include -D_KERNEL \ + -elf -mpreferred-stack-boundary=2 -I/usr/src/sys/sys -I../afs +DBUG = -O2 +DEFINES= -DAFSDEBUG -DKERNEL -DAFS -DVICE -DNFS -DUFS -DINET -DQUOTA -DGETMOUNT +OPTF=${OPT} +OPTF2=${OPT2} +CFLAGS=-I. -I.. ${FSINCLUDES} $(DEFINES) $(KDEFS) $(KOPTS) ${DBUG} + + +# Name of directory to hold object files and libraries. +KOBJ = STATIC + +# This tells Makefile.common to use it's single directory build target. +COMPDIRS = single_compdir + +include Makefile.common + +setup: + -mkdir $(KOBJ) + -rm $(KOBJ)/Makefile $(KOBJ)/Makefile.common + ln -s ../Makefile $(KOBJ)/Makefile + ln -s ../Makefile.common $(KOBJ)/Makefile.common + -rm -f h net netinet rpc ufs nfs machine sys vm + -ln -s /usr/src/sys/net net + -ln -s /usr/src/sys/i386/include machine + -ln -s /usr/src/sys/netinet netinet + -ln -s /usr/src/sys/nfs nfs + -ln -s /usr/include/rpc rpc + -ln -s /usr/src/sys/sys sys + -ln -s /usr/src/sys/ufs/ufs ufs + -ln -s /usr/src/sys/sys h + -ln -s /usr/src/sys/vm vm + -touch $(KOBJ)/sec_net.h + + +# Below this line are targets when in the COMMON directory: +LIBAFS = libafs.o +LIBAFSNONFS = libafs.nonfs.o + +DEST_LIBAFS = ${DESTDIR}/root.client/bin/${LIBAFS} +DEST_LIBAFSNONFS = ${DESTDIR}/root.client/bin/${LIBAFSNONFS} + + +# libafs: $(DEST_LIBAFS) $(DEST_LIBAFSNONFS) +# libafs: $(DEST_LIBAFSNONFS) +libafs: + echo WARNING: No kernel module for ${SYS_NAME} + + +$(DEST_LIBAFS): $(LIBAFS) + $(INSTALL) -f $? $@ + +$(DEST_LIBAFSNONFS): $(LIBAFSNONFS) + $(INSTALL) -f $? $@ + +${LIBAFS}: $(AFSAOBJS) $(AFSNFSOBJS) + $(LD) -r -o ${LIBAFS} ${AFSAOBJS} ${AFSNFSOBJS} + +${LIBAFSNONFS}: $(AFSAOBJS) $(AFSNONFSOBJS) + $(LD) -r -o ${LIBAFSNONFS} ${AFSAOBJS} ${AFSNONFSOBJS} + + +# Object build rules: +osi_groups.o: $(AFS)/osi_groups.c + $(CRULE1) +osi_file.o: $(AFS)/osi_file.c + $(CRULE1) +osi_inode.o: $(AFS)/osi_inode.c + $(CRULE1) +osi_misc.o: $(AFS)/osi_misc.c + $(CRULE1) +osi_sleep.o: $(AFS)/osi_sleep.c + $(CRULE1) +osi_vfsops_nfs.o: $(AFS)/osi_vfsops.c + $(CRULE1) -o osi_vfsops_nfs.o +osi_vfsops.o: $(AFS)/osi_vfsops.c + $(CRULE1) -DAFS_NONFSTRANS +osi_vm.o: $(AFS)/osi_vm.c + $(CRULE1) +osi_vnodeops.o: $(AFS)/osi_vnodeops.c + $(CRULE1) diff --git a/src/libafsrpc/Makefile b/src/libafsrpc/Makefile index add1ed1..543e3c0 100644 --- a/src/libafsrpc/Makefile +++ b/src/libafsrpc/Makefile @@ -326,6 +326,8 @@ syscall.o: ${SYS}/syscall.s ${AS} -P ${CFLAGS} -D_NO_PROTO -DMACH -DOSF -nostdinc -traditional -DASSEMBLER ${SYS}/syscall.s; \ ${AS} -o syscall.o syscall.i; \ rm -f syscall.ss syscall.i;; \ + *fbsd* ) \ + touch syscall.o ;; \ *) \ /lib/cpp ${SFLAGS} ${SYS}/syscall.s syscall.ss; \ as -o syscall.o syscall.ss; \ diff --git a/src/libuafs/MakefileProto.FBSD b/src/libuafs/MakefileProto.FBSD new file mode 100644 index 0000000..d493755 --- /dev/null +++ b/src/libuafs/MakefileProto.FBSD @@ -0,0 +1,76 @@ +#/* Copyright (C) 1995, 1989 Transarc Corporation - All rights reserved */ +# +# MakefileProto for Solaris systems +# + +include ../config/Makefile.${SYS_NAME} + +MKDIR_IF_NEEDED=[ -d $$1 ] || mkdir -p $$1 + +# System specific build commands and flags +CC = gcc +DEFINES= -D_REENTRANT -DAFSDEBUG -DKERNEL -DUKERNEL -DAFS -DVICE +KOPTS= +CFLAGS=-I. -I.. ${FSINCLUDES} $(DEFINES) $(KOPTS) ${DBUG} +OPTF=-O +# WEBOPTS = -I../nsapi -DNETSCAPE_NSAPI -DNET_SSL -DXP_UNIX -DMCC_HTTPD + +TEST_CFLAGS=-pthread -D_REENTRANT -DAFS_PTHREAD_ENV -DAFS_FBSD40_ENV +TEST_LDFLAGS= +TEST_LIBS= + +LIBUAFS = libuafs.a +LIBAFSWEB = nsafs.so +LIBAFSWEBKRB = nsafs.krb.so + +include Makefile.common + +setup_common: + -rm -f h net netinet rpc ufs nfs machine sys inet nsapi + -ln -s /usr/include/sys h + -ln -s /usr/include/net net + -ln -s /usr/include/netinet netinet + -ln -s /usr/include/rpc rpc + -ln -s /usr/include/sys sys + -ln -s /usr/include/nfs nfs + -ln -s /usr/include/inet inet + -ln -s /usr/include/ufs ufs + -ln -s $(NS_INCL) nsapi + +setup_uafs: setup_common + set UAFS; $(MKDIR_IF_NEEDED) + -rm -f UAFS/Makefile UAFS/Makefile.common + ln -s ../Makefile UAFS/Makefile + ln -s ../Makefile.common UAFS/Makefile.common + +setup_nsafs: setup_common + set AFSWEB; $(MKDIR_IF_NEEDED) + -rm -f AFSWEB/Makefile AFSWEB/Makefile.common + ln -s ../Makefile AFSWEB/Makefile + ln -s ../Makefile.common AFSWEB/Makefile.common + +UAFS/$(LIBUAFS): setup_uafs + cd UAFS; \ + $(MAKE) $(LIBUAFS) DESTDIR=${DESTDIR} + +AFSWEB/$(LIBAFSWEB): setup_nsafs +cd AFSWEB; \ + $(MAKE) $(LIBAFSWEB) DESTDIR=${DESTDIR} + +AFSWEB/$(LIBAFSWEBKRB): setup_nsafs + cd AFSWEB; \ + $(MAKE) $(LIBAFSWEBKRB) DESTDIR=${DESTDIR} + +# Below this line are targets when in the COMMON directory: + +$(LIBUAFS): $(UAFSOBJ) + -rm -f $(LIBUAFS) + $(AR) $(ARFLAGS) $(LIBUAFS) $(UAFSOBJ) + +$(LIBAFSWEB): $(AFSWEBOBJ) ${DES}/libdes.a + -rm -f $(LIBAFSWEB) + ld -b $(LIBAFSWEB) $(AFSWEBOBJ) ${DES}/libdes.a $(WEBLIBS) + +$(LIBAFSWEBKRB): $(AFSWEBOBJKRB) ${DES}/libdes.a + -rm -f $(LIBAFSWEBKRB) + ld -b $(LIBAFSWEBKRB) $(AFSWEBOBJKRB) ${DES}/libdes.a $(WEBLIBS) diff --git a/src/login/login.c b/src/login/login.c index 56ba397..5290524 100644 --- a/src/login/login.c +++ b/src/login/login.c @@ -53,6 +53,8 @@ char copyright[] = #if !defined(AFS_HPUX_ENV) && !defined(AFS_AIX_ENV) #if defined(AFS_SUN_ENV) || (defined(AFS_ATHENA_STDENV) && !defined(AFS_DEC_ENV)) || defined(AFS_OSF_ENV) #include +#elif defined(AFS_FBSD_ENV) +#include #else #include #endif @@ -71,6 +73,10 @@ char copyright[] = #include #include #endif +#ifdef AFS_FBSD_ENV +#define USE_OLD_TTY 1 +#include +#endif #include #include @@ -79,7 +85,7 @@ char copyright[] = #include #endif #include -#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 #endif #include diff --git a/src/lwp/Makefile b/src/lwp/Makefile index 022145f..9e44ef5 100644 --- a/src/lwp/Makefile +++ b/src/lwp/Makefile @@ -69,7 +69,11 @@ process.o : process.s process.c rm process.ss ;; \ ppc_darwin* ) \ $(CC) -c ${XCFLAGS} -I${SRCDIR}include process.s;; \ - hp* | *_linux* | sgi_64 | sgi_65) \ + i386_fbsd* ) \ + /usr/bin/cpp -P process.fbsd.s > process.ss; \ + ${AS} -o process.o process.ss; \ + rm process.ss ;; \ + hp* | *_linux* | sgi_64 | sgi_65 ) \ ${CC} ${CFLAGS} -c process.c;; \ ncrx86_*) \ /usr/ccs/lib/cpp -P -I${SRCDIR}include process.s process.ss; \ diff --git a/src/lwp/lwp.c b/src/lwp/lwp.c index 4b9e42b..1a40ca8 100644 --- a/src/lwp/lwp.c +++ b/src/lwp/lwp.c @@ -343,7 +343,7 @@ int LWP_CreateProcess(ep, stacksize, priority, parm, name, pid) #ifdef __hp9000s800 savecontext(Create_Process_Part2, &temp2->context, stackptr+MINFRAME); #else -#if defined(AFS_SGI62_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SGI62_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) /* Need to have the sp on an 8-byte boundary for storing doubles. */ savecontext(Create_Process_Part2, &temp2->context, stackptr+stacksize-16); /* 16 = 2 * jmp_buf_type*/ @@ -485,7 +485,7 @@ int LWP_DestroyProcess(pid) /* destroy a lightweight process */ savecontext(Dispatcher, &(temp -> context), &(LWPANCHOR.dsptchstack[MINFRAME])); #else -#if defined(AFS_SGI62_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SGI62_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) savecontext(Dispatcher, &(temp -> context), &(LWPANCHOR.dsptchstack[(sizeof LWPANCHOR.dsptchstack)-8])); #else diff --git a/src/lwp/preempt.c b/src/lwp/preempt.c index e95dacb..0b2bf52 100644 --- a/src/lwp/preempt.c +++ b/src/lwp/preempt.c @@ -17,7 +17,7 @@ \*******************************************************************/ #include -#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 diff --git a/src/lwp/process.c b/src/lwp/process.c index 155d60b..32aa938 100644 --- a/src/lwp/process.c +++ b/src/lwp/process.c @@ -50,6 +50,8 @@ extern char PRE_Block; /* used in lwp.c and process.s */ #else #error Unsupported linux LWP system type. #endif +#elif defined(AFS_X86_FBSD_ENV) +#define LWP_SP 4 #elif defined(AFS_DARWIN_ENV) #define LWP_SP 16 #else diff --git a/src/lwp/process.fbsd.s b/src/lwp/process.fbsd.s new file mode 100644 index 0000000..18dcacf --- /dev/null +++ b/src/lwp/process.fbsd.s @@ -0,0 +1,90 @@ +/* + * Copyright 2000, International Business Machines Corporation and others. + * All Rights Reserved. + * + * This software has been released under the terms of the IBM Public + * License. For details, see the LICENSE file in the top-level source + * directory or online at http://www.openafs.org/dl/license10.html + */ + +#define IGNORE_STDS_H 1 +/* Sun 386i... I hope this does the right thing!!! + * + * Written by Derek Atkins + * (debugging help by Chris Provenzano ) + * 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 + + + diff --git a/src/lwp/timer.c b/src/lwp/timer.c index 1efa91b..09de7e6 100644 --- a/src/lwp/timer.c +++ b/src/lwp/timer.c @@ -52,7 +52,7 @@ typedef unsigned char bool; static globalInitDone = 0; -#if !defined(AFS_HPUX_ENV) && !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) +#if !defined(AFS_HPUX_ENV) && !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV) extern insque(); #endif @@ -256,7 +256,7 @@ struct TM_Elem *TM_GetEarliest(tlist) return (e == tlist ? NULL : e); } -#if defined(AFS_HPUX_ENV) || defined(AFS_NT40_ENV) +#if defined(AFS_HPUX_ENV) || defined(AFS_NT40_ENV) || defined(AFS_FBSD_ENV) /* This used to be in hputils.c, but it's only use is in the LWP package. */ /* * Emulate the vax instructions for queue insertion and deletion, somewhat. @@ -285,4 +285,4 @@ void remque(struct TM_Elem *elementp) elementp->Prev = elementp->Next = (struct TM_Elem*)0; } -#endif /* AFS_HPUX_ENV || AFS_NT40_ENV */ +#endif /* AFS_HPUX_ENV || AFS_NT40_ENV || AFS_FBSD_ENV */ diff --git a/src/lwp/waitkey.c b/src/lwp/waitkey.c index fd9f615..fc7be40 100644 --- a/src/lwp/waitkey.c +++ b/src/lwp/waitkey.c @@ -154,7 +154,7 @@ int LWP_WaitForKeystroke(int seconds) if (stdin->_IO_read_ptr < stdin->_IO_read_end) return 1; #else -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) if (stdin->_bf._size > 0) return 1; #else diff --git a/src/package/gram.y b/src/package/gram.y index 7110721..4dd02e3 100644 --- a/src/package/gram.y +++ b/src/package/gram.y @@ -26,7 +26,7 @@ char *emalloc(); -#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) +#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_FBSD_ENV) int test_linecounter; /*Line number currently being parsed*/ char *ch2str(); char *appendchtostr(); diff --git a/src/package/test_gram.y b/src/package/test_gram.y index 2d52a99..6bc69c8 100644 --- a/src/package/test_gram.y +++ b/src/package/test_gram.y @@ -28,7 +28,7 @@ char *emalloc(); -#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) +#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_FBSD_ENV) int test_linecounter; /*Line number currently being parsed*/ char *ch2str(); diff --git a/src/pam/Makefile b/src/pam/Makefile index eb37016..9b218cb 100644 --- a/src/pam/Makefile +++ b/src/pam/Makefile @@ -52,6 +52,8 @@ pam_afs.so.1: $(SHOBJS) afs_setcred.o $(SHOBJS) $(LIBS) ;; \ *linux*) \ $(CC) $(LDFLAGS) -o $@ afs_setcred.o $(SHOBJS) $(LIBS) ;;\ + *fbsd*) \ + $(CC) $(LDFLAGS) -o $@ afs_setcred.o $(SHOBJS) $(LIBS) ;;\ * ) \ echo No link line for system $(SYS_NAME). ;; \ esac @@ -67,6 +69,8 @@ pam_afs.krb.so.1: $(SHOBJS) afs_setcred_krb.o afs_setcred_krb.o $(SHOBJS) $(LDFLAGS) $(KLIBS) ;; \ *linux*) \ $(CC) $(LDFLAGS) -o $@ afs_setcred_krb.o $(SHOBJS) $(KLIBS) ;;\ + *fbsd*) \ + $(CC) $(LDFLAGS) -o $@ afs_setcred_krb.o $(SHOBJS) $(KLIBS) ;;\ * ) \ echo No link line for system $(SYS_NAME). ;; \ esac @@ -80,6 +84,8 @@ test_pam: test_pam.o $(CC) $(CFLAGS) -o $@ test_pam.o ${PAMLIBS};; \ *linux*) \ $(CC) $(CFLAGS) -rdynamic -o $@ test_pam.o -lpam -ldl;; \ + *fbsd*) \ + $(CC) $(CFLAGS) -rdynamic -o $@ test_pam.o -lpam ;; \ *) \ echo No link line for system $(SYS_NAME). ;; \ esac diff --git a/src/pam/test_pam.c b/src/pam/test_pam.c index f5c928e..1939437 100644 --- a/src/pam/test_pam.c +++ b/src/pam/test_pam.c @@ -29,7 +29,7 @@ static const char *service = "afstest"; static const char *new_envstring = "GOTHEREVIATESTPAM=1"; static const char *new_homestring = "HOME=/tmp"; -#ifdef AFS_LINUX20_ENV +#if defined(AFS_LINUX20_ENV) || defined(AFS_FBSD_ENV) #define getpassphrase getpass #endif diff --git a/src/pinstall/install.c b/src/pinstall/install.c index e9f811c..53e4ed8 100644 --- a/src/pinstall/install.c +++ b/src/pinstall/install.c @@ -82,7 +82,7 @@ struct stat istat, ostat; extern int errno; extern int sys_nerr; -#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD40_ENV) extern char *sys_errlist[]; #endif #if defined(AFS_AIX_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DECOSF_ENV) || defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) diff --git a/src/rcp/rcp.c b/src/rcp/rcp.c index bf7db5b..a11c525 100644 --- a/src/rcp/rcp.c +++ b/src/rcp/rcp.c @@ -78,7 +78,7 @@ static char sccsid[] = "@(#)rcp.c 5.11 (Berkeley) 9/22/88"; int rem; char *colon(), *index(), *rindex(), *malloc(), *strcpy(); int errs; -#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) extern char *sys_errlist[]; #endif void lostconn(); diff --git a/src/rsh/rcmd.c b/src/rsh/rcmd.c index 9109b96..c043e1c 100644 --- a/src/rsh/rcmd.c +++ b/src/rsh/rcmd.c @@ -97,7 +97,7 @@ rcmd(ahost, rport, locuser, remuser, cmd, fd2p) #endif char **ahost; u_short rport; -#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) const char *locuser, *remuser, *cmd; #else char *locuser, *remuser, *cmd; @@ -359,7 +359,7 @@ rresvport(alport) int _check_rhosts_file = 1; -#if defined(AFS_HPUX102_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_HPUX102_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) ruserok(rhost, superuser, ruser, luser) const char *rhost; int superuser; diff --git a/src/rx/FBSD/rx_kmutex.h b/src/rx/FBSD/rx_kmutex.h new file mode 100644 index 0000000..924d8c2 --- /dev/null +++ b/src/rx/FBSD/rx_kmutex.h @@ -0,0 +1,96 @@ +/* Copyright Transarc Corporation 1998 - All Rights Reserved + * + * rx_kmutex.h - mutex and condition variable macros for kernel environment. + * + * DUX implementation. + */ + +#ifndef _RX_KMUTEX_H_ +#define _RX_KMUTEX_H_ + +#ifdef AFS_FBSD40_ENV + +#include +/* #include */ +/* #include */ + +#define RX_ENABLE_LOCKS 1 +#define AFS_GLOBAL_RXLOCK_KERNEL + +/* + * Condition variables + * + * In Digital Unix (OSF/1), we use something akin to the ancient sleep/wakeup + * mechanism. The condition variable itself plays no role; we just use its + * address as a convenient unique number. + */ +#define CV_INIT(cv,a,b,c) +#define CV_DESTROY(cv) +#define CV_WAIT(cv, lck) { \ + int isGlockOwner = ISAFS_GLOCK(); \ + if (isGlockOwner) AFS_GUNLOCK(); \ + assert_wait((vm_offset_t)(cv), 0); \ + MUTEX_EXIT(lck); \ + thread_block(); \ + if (isGlockOwner) AFS_GLOCK(); \ + MUTEX_ENTER(lck); \ + } + +#define CV_TIMEDWAIT(cv,lck,t) { \ + int isGlockOwner = ISAFS_GLOCK(); \ + if (isGlockOwner) AFS_GUNLOCK(); \ + assert_wait((vm_offset_t)(cv), 0); \ + thread_set_timeout(t); \ + MUTEX_EXIT(lck); \ + thread_block(); \ + if (isGlockOwner) AFS_GLOCK(); \ + MUTEX_ENTER(lck); \ + +#define CV_SIGNAL(cv) thread_wakeup_one((vm_offset_t)(cv)) +#define CV_BROADCAST(cv) thread_wakeup((vm_offset_t)(cv)) + +typedef struct { + struct simplelock lock; +} afs_kmutex_t; +typedef int afs_kcondvar_t; + +#define osi_rxWakeup(cv) thread_wakeup((vm_offset_t)(cv)) + +#define LOCK_INIT(a,b) \ + do { \ + usimple_lock_init(&(a)->lock); \ + } while(0); +#define MUTEX_INIT(a,b,c,d) \ + do { \ + usimple_lock_init(&(a)->lock); \ + } while(0); +#define MUTEX_DESTROY(a) \ + do { \ + usimple_lock_terminate(&(a)->lock); \ + } while(0); +#define MUTEX_ENTER(a) \ + do { \ + usimple_lock(&(a)->lock); \ + } while(0); +#define MUTEX_TRYENTER(a) \ + usimple_lock(&(a)->lock) +#define MUTEX_EXIT(a) \ + do { \ + usimple_unlock(&(a)->lock); \ + } while(0); + +#undef MUTEX_ISMINE +#define MUTEX_ISMINE(a) 1 +/* + #define MUTEX_ISMINE(a) + (((afs_kmutex_t *)(a))->owner == current_thread()) +*/ + +#undef osirx_AssertMine +extern void osirx_AssertMine(afs_kmutex_t *lockaddr, char *msg); + +#endif /* FBSD40 */ + + +#endif /* _RX_KMUTEX_H_ */ + diff --git a/src/rx/FBSD/rx_knet.c b/src/rx/FBSD/rx_knet.c new file mode 100644 index 0000000..30ae839 --- /dev/null +++ b/src/rx/FBSD/rx_knet.c @@ -0,0 +1,361 @@ +/* +**************************************************************************** +* Copyright IBM Corporation 1988, 1989 - All Rights Reserved * +* Copyright Transarc Corporation 1989 - All Rights Reserved * +* * +* Permission to use, copy, modify, and distribute this software and its * +* documentation for any purpose and without fee is hereby granted, * +* provided that the above copyright notice appear in all copies and * +* that both that copyright notice and this permission notice appear in * +* supporting documentation, and that the name of IBM not be used in * +* advertising or publicity pertaining to distribution of the software * +* without specific, written prior permission. * +* * +* IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL IBM * +* BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY * +* DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER * +* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING * +* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * +**************************************************************************** +*/ + +#include "../afs/param.h" +#ifdef AFS_FBSD40_ENV +#include "../rx/rx_kcommon.h" + + +static struct protosw parent_proto; /* udp proto switch */ +static void rxk_input (struct mbuf *am, int iphlen); +static void rxk_fasttimo (void); + +/* start intercepting basic calls */ +rxk_init() { + register struct protosw *tpro, *last; + if (rxk_initDone) return 0; + + last = inetdomain.dom_protoswNPROTOSW; + for (tpro = inetdomain.dom_protosw; tpro < last; tpro++) + if (tpro->pr_protocol == IPPROTO_UDP) { + /* force UDP checksumming on for AFS */ + extern int udpcksum; + udpcksum = 1; + bcopy(tpro, &parent_proto, sizeof(parent_proto)); + tpro->pr_input = rxk_input; + tpro->pr_fasttimo = rxk_fasttimo; + /* + * don't bother with pr_drain and pr_ctlinput + * until we have something to do + */ + rxk_initDone = 1; + return 0; + } + osi_Panic("inet:no udp"); +} + + +static void rxk_input (struct mbuf *am, int iphlen) +{ + void (*tproc)(); + register unsigned short *tsp; + int hdr; + struct udphdr *tu; + register struct ip *ti; + struct udpiphdr *tvu; + register int i; + char *phandle; + afs_int32 code; + struct sockaddr_in taddr; + int tlen; + short port; + int data_len, comp_sum; + + SPLVAR; + NETPRI; + + /* make sure we have base ip and udp headers in first mbuf */ + if (iphlen > sizeof (struct ip)) { + ip_stripoptions(am, (struct mbuf *)0); + iphlen = sizeof (struct ip); + } + + if (am->m_len < sizeof(struct udpiphdr)) { + am = m_pullup(am, sizeof(struct udpiphdr)); + if (!am) { + USERPRI; + return; + } + } + + ti = mtod(am, struct ip *); + /* skip basic ip hdr */ + tu = (struct udphdr *)(((char *)ti) + sizeof(struct ip)); + + /* now read the port out */ + port = tu->uh_dport; + + if (port) { + for(tsp=rxk_ports, i=0; iui_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 */ diff --git a/src/rx/Makefile b/src/rx/Makefile index e0a5191..1056e22 100644 --- a/src/rx/Makefile +++ b/src/rx/Makefile @@ -122,6 +122,8 @@ kinstall: includes case ${SYS_NAME} in \ alpha_dux* ) \ $(INSTALL) DUX/*.[ch] $(KERNELDIR)rx;; \ + i386_fbsd* ) \ + $(INSTALL) FBSD/*.[ch] $(KERNELDIR)rx;; \ *_linux* ) \ $(INSTALL) LINUX/*.[ch] $(KERNELDIR)rx;; \ rs_aix* ) \ diff --git a/src/rx/rx_getaddr.c b/src/rx/rx_getaddr.c index 5a0c41a..1432d6e 100644 --- a/src/rx/rx_getaddr.c +++ b/src/rx/rx_getaddr.c @@ -20,11 +20,12 @@ #include #include #include -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include #include #include #endif + /* * By including this, we get any system dependencies. In particular, * the pthreads for solaris requires the socket call to be mapped. @@ -105,7 +106,7 @@ afs_int32 rxi_getaddr () #undef socket #endif /* UKERNEL */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #define ROUNDUP(a) \ ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len)) @@ -132,7 +133,7 @@ rt_xaddrs(cp, cplim, rtinfo) /* this function returns the total number of interface addresses ** the buffer has to be passed in by the caller */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) int rx_getAllAddr (buffer,maxSize) afs_int32 buffer[]; int maxSize; /* sizeof of buffer in afs_int32 units */ @@ -337,13 +338,13 @@ int maxSize; /* sizeof of buffer in afs_int32 units */ len = ifc.ifc_len / sizeof(struct ifreq); if (len > NIFS) len = NIFS; -#if defined(AFS_AIX41_ENV) || defined (AFS_DARWIN_ENV) +#if defined(AFS_AIX41_ENV) || defined (AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) if ( ifc.ifc_len > sizeof(ifs) ) /* safety check */ ifc.ifc_len = sizeof(ifs); for ( cp = (char *)ifc.ifc_buf, cplim= ifc.ifc_buf+ifc.ifc_len; cp < cplim; -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) cp += _SIZEOF_ADDR_IFREQ(*ifr)) #else cp += sizeof(ifr->ifr_name) + MAX(a->sin_len, sizeof(*a))) diff --git a/src/rx/rx_kcommon.c b/src/rx/rx_kcommon.c index a07dad1..73a140e 100644 --- a/src/rx/rx_kcommon.c +++ b/src/rx/rx_kcommon.c @@ -423,7 +423,7 @@ register struct rx_peer *pp; */ -#if ! defined(AFS_AIX_ENV) && ! defined(AFS_SUN5_ENV) && ! defined(UKERNEL) && ! defined(AFS_LINUX20_ENV) && !defined (AFS_DARWIN_ENV) +#if ! defined(AFS_AIX_ENV) && ! defined(AFS_SUN5_ENV) && ! defined(UKERNEL) && ! defined(AFS_LINUX20_ENV) && !defined (AFS_DARWIN_ENV) && !defined (AFS_FBSD_ENV) /* Routine called during the afsd "-shutdown" process to put things back to * the initial state. */ @@ -548,7 +548,7 @@ afs_int32 rxi_Findcbi(addr) #else /* AFS_USERSPACE_IP_ADDR */ -#if !defined(AFS_AIX41_ENV) && !defined(AFS_DUX40_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_AIX41_ENV) && !defined(AFS_DUX40_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) #define IFADDR2SA(f) (&((f)->ifa_addr)) #else /* AFS_AIX41_ENV */ #define IFADDR2SA(f) ((f)->ifa_addr) @@ -569,14 +569,14 @@ int rxi_GetIFInfo() bzero(addrs, sizeof(addrs)); bzero(mtus, sizeof(mtus)); -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) TAILQ_FOREACH(ifn, &ifnet, if_link) { if (i >= ADDRSPERSITE) break; #else for (ifn = ifnet; ifn != NULL && i < ADDRSPERSITE; ifn = ifn->if_next) { #endif rxmtu = (ifn->if_mtu - RX_IPUDP_SIZE); -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) TAILQ_FOREACH(ifad, &ifn->if_addrhead, ifa_link) { if (i >= ADDRSPERSITE) break; #else @@ -636,7 +636,7 @@ rxi_FindIfnet(addr, pifad) /* if we're given an address, skip everything until we find it */ if (!*pifad) -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) *pifad = TAILQ_FIRST(&in_ifaddrhead); #else *pifad = in_ifaddr; @@ -644,14 +644,14 @@ rxi_FindIfnet(addr, pifad) else { if (((ppaddr & (*pifad)->ia_subnetmask) == (*pifad)->ia_subnet)) match_value = 2; /* don't find matching nets, just subnets */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) *pifad = TAILQ_NEXT(*pifad, ia_link); #else *pifad = (*pifad)->ia_next; #endif } -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) for (ifa = *pifad; ifa; ifa = TAILQ_NEXT(ifa, ia_link) ) { #else for (ifa = *pifad; ifa; ifa = ifa->ia_next ) { @@ -713,7 +713,7 @@ struct osi_socket *rxk_NewSocket(short aport) #endif AFS_STATCNT(osi_NewSocket); -#if defined(AFS_DARWIN_ENV) && defined(KERNEL_FUNNEL) +#if (defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)) && defined(KERNEL_FUNNEL) thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL); #endif #if defined(AFS_HPUX102_ENV) @@ -726,6 +726,8 @@ struct osi_socket *rxk_NewSocket(short aport) #else #ifdef AFS_SGI65_ENV code = socreate(AF_INET, &newSocket, SOCK_DGRAM,IPPROTO_UDP); +#elif defined(AFS_FBSD_ENV) + code = socreate(AF_INET, &newSocket, SOCK_DGRAM,IPPROTO_UDP, curproc); #else code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0); #endif /* AFS_SGI65_ENV */ @@ -760,9 +762,13 @@ struct osi_socket *rxk_NewSocket(short aport) if (code) osi_Panic("osi_NewSocket: last attempt to reserve 32K failed!\n"); } -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) myaddr.sin_len = sizeof(myaddr); +#if defined(AFS_FBSD_ENV) + code = sobind(newSocket, (struct sockaddr *)&myaddr, curproc); +#else code = sobind(newSocket, (struct sockaddr *)&myaddr); +#endif if (code) { printf("sobind fails\n"); soclose(newSocket); @@ -775,7 +781,7 @@ struct osi_socket *rxk_NewSocket(short aport) nam = m_get(M_WAIT, MT_SONAME); #endif if (nam == NULL) { -#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) +#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_FBSD_ENV) setuerror(ENOBUFS); #endif goto bad; @@ -789,6 +795,8 @@ struct osi_socket *rxk_NewSocket(short aport) BHV_PDATA(&bhv) = (void*)newSocket; code = sobind(&bhv, nam); m_freem(nam); +#elif defined(AFS_FBSD_ENV) + code = sobind(newSocket, nam, curproc); #else code = sobind(newSocket, nam); #endif @@ -988,7 +996,7 @@ void rxk_Listener(void) #ifdef AFS_SUN5_ENV rxk_ListenerPid = ttoproc(curthread)->p_pidp->pid_id; #endif /* AFS_SUN5_ENV */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) rxk_ListenerPid = current_proc()->p_pid; #endif #if defined(RX_ENABLE_LOCKS) && !defined(AFS_SUN5_ENV) @@ -1030,7 +1038,7 @@ void rxk_Listener(void) #endif /* AFS_SUN5_ENV */ } -#if !defined(AFS_LINUX20_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_LINUX20_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) /* The manner of stopping the rx listener thread may vary. Most unix's should * be able to call soclose. */ diff --git a/src/rx/rx_kcommon.h b/src/rx/rx_kcommon.h index 9f01116..389d66a 100644 --- a/src/rx/rx_kcommon.h +++ b/src/rx/rx_kcommon.h @@ -35,11 +35,19 @@ typedef unsigned short etap_event_t; #ifndef AFS_LINUX22_ENV #include "../h/socketvar.h" #include "../h/protosw.h" -#ifndef AFS_SUN5_ENV +#if !defined(AFS_SUN5_ENV) && !defined(AFS_FBSD_ENV) #include "../h/domain.h" #include "../h/dir.h" #include "../h/buf.h" #include "../h/mbuf.h" +#else +#if defined(AFS_FBSD_ENV) +#include "../h/dirent.h" +#include "../h/socket.h" +#include "../h/domain.h" +#include "../h/buf.h" +#include "../h/mbuf.h" +#endif /* AFS_FBSD_ENV */ #endif #endif /* AFS_LINUX22_ENV */ #ifdef AFS_SGI62_ENV @@ -106,4 +114,8 @@ extern struct ifnet *rxi_FindIfnet(); extern int rxk_initDone; +#if defined(AFS_FBSD_ENV) +extern struct domain inetdomain; +#endif /* AFS_FBSD_ENV */ + #endif /* _RX_KCOMMON_H_ */ diff --git a/src/rx/rx_packet.h b/src/rx/rx_packet.h index 6b2af42..cb49d1e 100644 --- a/src/rx/rx_packet.h +++ b/src/rx/rx_packet.h @@ -40,7 +40,7 @@ #define MAX(a,b) ((a)>(b)?(a):(b)) #endif #else /* AFS_NT40_ENV */ -#if !defined(AFS_DARWIN_ENV) && !defined(AFS_USR_DARWIN_ENV) +#if !defined(AFS_DARWIN_ENV) && !defined(AFS_USR_DARWIN_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_USR_FBSD_ENV) #include /* MIN, MAX on Solaris */ #endif #include /* MIN, MAX elsewhere */ diff --git a/src/rx/rx_rdwr.c b/src/rx/rx_rdwr.c index 0685433..0b40990 100644 --- a/src/rx/rx_rdwr.c +++ b/src/rx/rx_rdwr.c @@ -10,7 +10,7 @@ #ifdef KERNEL #include "../afs/param.h" #ifndef UKERNEL -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include "../afs/sysincludes.h" #else #include "../h/types.h" diff --git a/src/rxgen/rpc_main.c b/src/rxgen/rpc_main.c index b4a6bcc..e96aba4 100644 --- a/src/rxgen/rpc_main.c +++ b/src/rxgen/rpc_main.c @@ -88,6 +88,8 @@ int debug = 0; static char *cmdname; #ifdef AFS_SUN5_ENV static char CPP[] = "/usr/ccs/lib/cpp"; +#elif defined(AFS_FBSD_ENV) +static char CPP[] = "/usr/bin/cpp"; #elif defined(AFS_NT40_ENV) static char CPP[MAXCMDLINE]; #elif defined(AFS_DARWIN_ENV) diff --git a/src/sys/Makefile b/src/sys/Makefile index 22c1672..72267e6 100644 --- a/src/sys/Makefile +++ b/src/sys/Makefile @@ -87,6 +87,8 @@ syscall.o: syscall.s rm -f syscall.ss syscall.i;; \ hp_ux11? ) \ touch syscall.o;; \ + i386_fbsd* ) \ + touch syscall.o;; \ *) \ /lib/cpp ${SFLAGS} syscall.s syscall.ss; \ as -o syscall.o syscall.ss; \ diff --git a/src/uss/uss_common.h b/src/uss/uss_common.h index ee9a2ad..0b22fac 100644 --- a/src/uss/uss_common.h +++ b/src/uss/uss_common.h @@ -60,7 +60,7 @@ #define uss_VolumeLen 300 #define uss_DirPoolLen 300 -#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) extern char *sys_errlist[]; #endif diff --git a/src/util/netutils.c b/src/util/netutils.c index 6cd16c0..684ebc7 100644 --- a/src/util/netutils.c +++ b/src/util/netutils.c @@ -19,6 +19,9 @@ #include "../afs/sysincludes.h" #include "../afs/afsincludes.h" #else +#ifdef __FreeBSD__ +#include +#endif #include #include #include diff --git a/src/venus/kdump.c b/src/venus/kdump.c index 72099d8..dc13a12 100644 --- a/src/venus/kdump.c +++ b/src/venus/kdump.c @@ -195,7 +195,7 @@ typedef struct adaptive_mutex2 adaptive_mutex2_t; #include #include #else /* AFS_MACH_ENV */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include #include #include @@ -938,7 +938,7 @@ int cnt, size; #endif /*AFS_KDUMP_LIB */ #endif -#ifndef AFS_DARWIN_ENV +#if !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) int findsym( char *sname, off_t *offset ) { @@ -1010,7 +1010,7 @@ findsym( char *sname, off_t *offset ) kdump() { int cell, cnt, cnt1; -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) printf("Kdump not supported\n"); #else #ifndef AFS_KDUMP_LIB @@ -1146,7 +1146,7 @@ kdump() return 0; } -#ifndef AFS_DARWIN_ENV +#if !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) int Sum_cellnames=0, Sum_userstp=0, Sum_volnames=0, Sum_exps=0, Sum_nfssysnames=0; int Sum_vcachemvids=0, Sum_vcachelinkData=0, Sum_vcacheacc=0, Sum_vcachelocks=0; diff --git a/src/venus/up.c b/src/venus/up.c index 9b0b614..de24918 100644 --- a/src/venus/up.c +++ b/src/venus/up.c @@ -42,7 +42,7 @@ extern char *index (); extern char *rindex (); -#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) extern sys_nerr; extern char *sys_errlist[]; #endif diff --git a/src/viced/afsfileprocs.c b/src/viced/afsfileprocs.c index 75aadd9..9bfb395 100644 --- a/src/viced/afsfileprocs.c +++ b/src/viced/afsfileprocs.c @@ -74,7 +74,7 @@ #include #include #include -#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 #endif #if !defined(AFS_NT40_ENV) @@ -85,7 +85,7 @@ #include #include #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 #endif #endif diff --git a/src/vol/Makefile b/src/vol/Makefile index 328cdd6..7259209 100644 --- a/src/vol/Makefile +++ b/src/vol/Makefile @@ -92,7 +92,7 @@ listinodes.o: listinodes.c AFS_component_version_number.c gi: ${DESTDIR}/lib/afs/libsys.a case ${SYS_NAME} in \ - *linux* | sgi_* ) \ + *linux* | sgi_* | *fbsd* ) \ echo "Don't build gi on ${SYS_NAME}";; \ *) \ ${CC} ${CFLAGS} -c gi.c ; \ diff --git a/src/vol/devname.c b/src/vol/devname.c index 6e020a1..3af8874 100644 --- a/src/vol/devname.c +++ b/src/vol/devname.c @@ -21,7 +21,7 @@ #ifdef AFS_SUN5_ENV #include #else -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include #include #else @@ -29,7 +29,7 @@ #endif #endif #else /* AFS_VFSINCL_ENV */ -#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX22_ENV) +#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_FBSD_ENV) #include #endif #endif /* AFS_VFSINCL_ENV */ diff --git a/src/vol/listinodes.c b/src/vol/listinodes.c index 2ba70e7..5222b8c 100644 --- a/src/vol/listinodes.c +++ b/src/vol/listinodes.c @@ -10,6 +10,7 @@ #ifndef lint #endif /* + System: VICE-TWO Module: listinodes.c Institution: The Information Technology Center, Carnegie-Mellon University @@ -49,7 +50,7 @@ int *forcep, forceR; #ifdef AFS_SUN5_ENV #include #else -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include #include #define itod ino_to_fsba @@ -71,7 +72,7 @@ int *forcep, forceR; #ifdef AFS_SUN5_ENV #include #else -#ifndef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) #include #endif #endif @@ -1251,7 +1252,7 @@ int ListViceInodes(devname, mountedOn, resultFile, judgeInode, judgeParam, force if ( (super.fs.fs_magic != FS_MAGIC) || (super.fs.fs_ncg < 1) -#if defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) || (super.fs.fs_cpg < 1) #else || (super.fs.fs_cpg < 1 || super.fs.fs_cpg > MAXCPG) diff --git a/src/vol/partition.c b/src/vol/partition.c index fa8c3c4..ab012fa 100644 --- a/src/vol/partition.c +++ b/src/vol/partition.c @@ -10,6 +10,7 @@ #ifndef lint #endif /* + System: VICE-TWO Module: partition.c Institution: The Information Technology Center, Carnegie-Mellon University @@ -29,7 +30,7 @@ #if AFS_HAVE_STATVFS #include #endif /* AFS_HAVE_STATVFS */ -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include #endif @@ -43,7 +44,7 @@ #ifdef AFS_SUN5_ENV #include #else -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include #include #else @@ -51,7 +52,7 @@ #endif #endif #else /* AFS_VFSINCL_ENV */ -#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV) +#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV) #include #endif #endif /* AFS_VFSINCL_ENV */ @@ -453,7 +454,7 @@ int VAttachPartitions(void) } #endif -#if defined(AFS_DUX40_ENV) || defined(AFS_DARWIN_ENV) +#if defined(AFS_DUX40_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) int VAttachPartitions(void) { int errors = 0; diff --git a/src/vol/vol-salvage.c b/src/vol/vol-salvage.c index eb74b08..5bed33b 100644 --- a/src/vol/vol-salvage.c +++ b/src/vol/vol-salvage.c @@ -120,7 +120,7 @@ Vnodes with 0 inode pointers in RW volumes are now deleted. #ifdef AFS_SUN5_ENV #include #else -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include #include #else @@ -131,7 +131,7 @@ Vnodes with 0 inode pointers in RW volumes are now deleted. #ifdef AFS_OSF_ENV #include #else /* AFS_OSF_ENV */ -#ifndef AFS_LINUX20_ENV +#if !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV) #include #endif #endif diff --git a/src/vol/volume.c b/src/vol/volume.c index fc45201..2032ff2 100644 --- a/src/vol/volume.c +++ b/src/vol/volume.c @@ -33,7 +33,7 @@ #ifdef AFS_SUN5_ENV #include #else -#ifdef AFS_DARWIN_ENV +#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) #include #include #else @@ -41,7 +41,7 @@ #endif #endif #else /* AFS_VFSINCL_ENV */ -#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX20_ENV) +#if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV) #include #endif #endif /* AFS_VFSINCL_ENV */