which included commits to RCS files with non-trunk default branches.
alpha_dux40
alpha_dux50 (only tested on 5.0A)
+ i386_fbsd42 (gmake is required to build for FreeBSD)
i386_linux22
- i386_linux24 (only tested with 2.4.0 kernel)
+ i386_linux24
rs_aix42
sgi_65 (file server not tested)
sun4x_56
ppc_darwin_13
ppc_linux22
ppc_linux24
- alpha_linux22 (DES does not work, will require one more change to
- compile)
+ alpha_linux22
+ alpha_linux24
+ ia64_linux24
+ sparc_linux22
+ sparc_linux24
+ sparc64_linux22
+ sparc64_linux24
hp_ux110 (No client support, but db servers and utilities work)
hp_ux102 (No client support, but db servers and utilities work)
#undef HAVE_GETHOSTBYNAME
#undef HAVE_RES_SEARCH
#undef HAVE_SOCKET
+#undef STRUCT_SOCKADDR_HAS_SA_LEN
#if ENDIANESS_IN_SYS_PARAM_H
# ifndef KERNEL
#undef STRUCT_INODE_HAS_I_TRUNCATE_SEM
#undef STRUCT_INODE_HAS_I_DIRTY_DATA_BUFFERS
#undef STRUCT_INODE_HAS_I_DEVICES
+#undef EXPORTED_TASKLIST_LOCK
+#undef COMPLETION_H_EXISTS
+#undef ssize_t
/* glue for RedHat kernel bug */
#undef ENABLE_REDHAT_BUILDSYS
AC_MINIX
dnl Various compiler setup.
-AC_C_INLINE
-AC_C_CONST
-AC_PROG_CC
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_TYPE_SIGNAL
LINUX_FS_STRUCT_INODE_HAS_I_DIRTY_DATA_BUFFERS
LINUX_FS_STRUCT_INODE_HAS_I_DEVICES
LINUX_INODE_SETATTR_RETURN_TYPE
+ LINUX_COMPLETION_H_EXISTS
+ LINUX_EXPORTS_TASKLIST_LOCK
LINUX_NEED_RHCONFIG
LINUX_WHICH_MODULES
+ if test "x$ac_cv_linux_exports_tasklist_lock" = "xyes" ; then
+ AC_DEFINE(EXPORTED_TASKLIST_LOCK)
+ fi
+ if test "x$ac_cv_linux_completion_h_exists" = "xyes" ; then
+ AC_DEFINE(COMPLETION_H_EXISTS)
+ fi
if test "x$ac_cv_linux_func_inode_setattr_returns_int" = "xyes" ; then
AC_DEFINE(INODE_SETATTR_NOT_VOID)
fi
SOLARIS_UFSVFS_HAS_DQRWLOCK
SOLARIS_PROC_HAS_P_COREFILE
;;
+ *-sunos*)
+ MKAFS_OSTYPE=SUNOS
+ enable_kernel_module=no
+ AC_MSG_RESULT(sun4)
+ ;;
*-hpux*)
MKAFS_OSTYPE=HPUX
AC_MSG_RESULT(hp_ux)
i?86-*-freebsd4.2*)
AFS_SYSNAME="i386_fbsd_42"
;;
+ i?86-*-freebsd4.3*)
+ AFS_SYSNAME="i386_fbsd_43"
+ ;;
+ i?86-*-freebsd4.4*)
+ AFS_SYSNAME="i386_fbsd_44"
+ ;;
+ i?86-*-freebsd4.5*)
+ AFS_SYSNAME="i386_fbsd_45"
+ ;;
+ i?86-*-freebsd4.6*)
+ AFS_SYSNAME="i386_fbsd_46"
+ ;;
hppa*-hp-hpux11*)
AFS_SYSNAME="hp_ux110"
;;
powerpc-apple-darwin5.5*)
AFS_SYSNAME="ppc_darwin_14"
;;
+ powerpc-apple-darwin6.0*)
+ AFS_SYSNAME="ppc_darwin_60"
+ ;;
+ powerpc-apple-darwin6.1*)
+ AFS_SYSNAME="ppc_darwin_60"
+ ;;
sparc-sun-solaris2.5*)
AFS_SYSNAME="sun4x_55"
;;
sparc-sun-solaris2.9)
AFS_SYSNAME="sun4x_59"
;;
+ sparc-sun-sunos4*)
+ AFS_SYSNAME="sun4_413"
+ ;;
i386-pc-solaris2.7)
AFS_SYSNAME="sunx86_57"
;;
DARWIN_INFOFILE=afs.${AFS_SYSNAME}.plist
;;
esac
-
+AC_CACHE_VAL(ac_cv_sockaddr_len,
+[
+AC_MSG_CHECKING([if struct sockaddr has sa_len field])
+AC_TRY_COMPILE( [#include <sys/types.h>
+#include <sys/socket.h>],
+[struct sockaddr *a;
+a->sa_len=0;], ac_cv_sockaddr_len=yes, ac_cv_sockaddr_len=no)
+AC_MSG_RESULT($ac_cv_sockaddr_len)])
+if test "$ac_cv_sockaddr_len" = "yes"; then
+ AC_DEFINE(STRUCT_SOCKADDR_HAS_SA_LEN)
+fi
if test "x${MKAFS_OSTYPE}" = "xIRIX"; then
echo Skipping library tests because they confuse Irix.
else
AC_CHECK_HEADERS(mntent.h sys/vfs.h sys/param.h sys/fs_types.h)
AC_CHECK_HEADERS(sys/mount.h strings.h termios.h signal.h)
AC_CHECK_HEADERS(windows.h malloc.h winsock2.h direct.h io.h)
-AC_CHECK_HEADERS(security/pam_modules.h siad.h usersec.h)
+AC_CHECK_HEADERS(security/pam_modules.h siad.h usersec.h ucontext.h)
AC_CHECK_FUNCS(utimes random srandom getdtablesize snprintf re_comp re_exec)
-AC_CHECK_FUNCS(setprogname getprogname)
+AC_CHECK_FUNCS(setprogname getprogname sigaction)
+AC_CHECK_TYPE(ssize_t, int)
dnl Directory PATH handling
if test "x$enable_transarc_paths" = "xyes" ; then
AC_INIT(Makefile.common)
-AM_INIT_AUTOMAKE(openafs-libafs,1.2.6)
+AM_INIT_AUTOMAKE(openafs-libafs,1.2.7)
AC_CONFIG_HEADER(config/afsconfig.h)
define(OPENAFS_CONFIGURE_LIBAFS)
+AC_PROG_CC
OPENAFS_CONFIGURE_COMMON
TOP_SRCDIR="${SRCDIR_PARENT}"
if ((wChild < 0) || (wChild >= 0xF000))
continue;
- wNext = max( wNext, wChild+1 );
+ wNext = max( wNext, (WORD) wChild+1 );
}
return wNext;
<P>Converts a volume into ASCII format and writes it to a file
<P><STRONG>Synopsis</STRONG>
<PRE><B>vos dump -id</B> <<VAR>volume name or ID</VAR>> [<B>-time</B> <<VAR>dump from time</VAR>>] [<B>-file</B> <<VAR>dump file</VAR>>]
- [<B>-server</B> <<VAR>server</VAR>>] [<B>-partition</B> <<VAR>partition</VAR>>] [<B>-cell</B> <<VAR>cell name</VAR>>]
+ [<B>-server</B> <<VAR>server</VAR>>] [<B>/partition</B> <<VAR>partition</VAR>>] [<B>-cell</B> <<VAR>cell name</VAR>>]
[<B>-noauth</B>] [<B>-localauth</B>] [<B>-verbose</B>] [<B>-help</B>]
<B>vos du -i</B> <<VAR>volume name or ID</VAR>> [<B>-t</B> <<VAR>dump from time</VAR>>] [<B>-f</B> <<VAR>dump file</VAR>>]
/*
* Time related macros
*/
+#ifndef AFS_DARWIN60_ENV
extern struct timeval time;
+#endif
#define osi_Time() (time.tv_sec)
#define afs_hz hz
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/DARWIN/osi_module.c,v 1.1.1.5 2002/01/22 19:48:05 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/DARWIN/osi_module.c,v 1.1.1.6 2002/09/26 18:58:04 hartmans Exp $");
#include "../afs/sysincludes.h"
#include "../afs/afsincludes.h"
+#ifdef AFS_DARWIN60_ENV /* not in Kernel.framework anymore !?! */
+#include <sys/syscall.h>
+#else
#include "../sys/syscall.h"
+#endif
#include <mach/kmod.h>
struct vfsconf afs_vfsconf;
struct vnode **dirvpp, struct vnode **vpp);
/* osi_vm.c */
extern void osi_VM_NukePages(struct vnode *vp, off_t offset, off_t size);
-extern int osi_VM_Setup(struct vcache *avc);
+extern int osi_VM_Setup(struct vcache *avc, int force);
#endif /* _OSI_PROTO_H_ */
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/DARWIN/osi_vm.c,v 1.1.1.6 2002/08/02 04:28:49 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/DARWIN/osi_vm.c,v 1.1.1.7 2002/09/26 18:58:05 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
#endif
}
-int osi_VM_Setup(struct vcache *avc) {
+int osi_VM_Setup(struct vcache *avc, int force) {
int error;
struct vnode *vp=AFSTOV(avc);
- if (UBCISVALID(vp) && (avc->states & CStatd)) {
+ if (UBCISVALID(vp) && ((avc->states & CStatd) || force)) {
if (!UBCINFOEXISTS(vp) && !ISSET(vp->v_flag, VTERMINATE)) {
osi_vnhold(avc,0);
+ avc->states |= CUBCinit;
AFS_GUNLOCK();
if ((error=ubc_info_init(&avc->v))) {
AFS_GLOCK();
+ avc->states &= ~CUBCinit;
AFS_RELE(avc);
return error;
}
simple_unlock(&avc->v.v_interlock);
#endif
AFS_GLOCK();
+ avc->states &= ~CUBCinit;
AFS_RELE(avc);
}
if (UBCINFOEXISTS(&avc->v))
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/DARWIN/osi_vnodeops.c,v 1.1.1.6 2002/05/10 23:43:37 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/DARWIN/osi_vnodeops.c,v 1.1.1.7 2002/09/26 18:58:05 hartmans Exp $");
#include <afs/sysincludes.h> /* Standard vendor system headers */
#include <afs/afsincludes.h> /* Afs-based standard headers */
osi_FlushPages(avc); /* hold bozon lock, but not basic vnode lock */
afs_BozonUnlock(&avc->pvnLock, avc);
AFS_GUNLOCK();
+#ifdef AFS_DARWIN14_ENV
+ if (UBCINFOEXISTS(ap->a_vp) && ap->a_vp->v_ubcinfo->ui_refcount < 2) {
+ ubc_hold(ap->a_vp);
+ if (ap->a_vp->v_ubcinfo->ui_refcount < 2) {
+ printf("afs: Imminent ui_refcount panic\n");
+ } else {
+ printf("afs: WARNING: ui_refcount panic averted\n");
+ }
+ }
+#endif
+
return code;
}
register struct vnode *vp = ap->a_vp;
register struct vcache *vc = VTOAFS(ap->a_vp);
int s = vc->states;
- char buf[20];
printf("tag %d, fid: %ld.%x.%x.%x, opens %d, writers %d", vp->v_tag, vc->fid.Cell,
vc->fid.Fid.Volume, vc->fid.Fid.Vnode, vc->fid.Fid.Unique, vc->opens,
vc->execsOrWriters);
printf("\n states%s%s%s%s%s", (s&CStatd) ? " statd" : "", (s&CRO) ? " readonly" : "",(s&CDirty) ? " dirty" : "",(s&CMAPPED) ? " mapped" : "", (s&CVFlushed) ? " flush in progress" : "");
- if (UBCISVALID(vp))
- printf("\n UBC: %s%s",
- UBCINFOEXISTS(vp) ? "exists, " : "does not exist",
+ if (UBCISVALID(vp)) {
+ printf("\n UBC: ");
+ if (UBCINFOEXISTS(vp)) {
+ printf("exists, ") ;
#ifdef AFS_DARWIN14_ENV
- UBCINFOEXISTS(vp) ?
- sprintf(buf, "refs %d", vp->v_ubcinfo->ui_refcount),buf : "");
+ printf("refs %d%s%s", vp->v_ubcinfo->ui_refcount,
+ ubc_issetflags(vp, UI_HASOBJREF) ? " HASOBJREF" : "",
+ ubc_issetflags(vp, UI_WASMAPPED) ? " WASMAPPED" : "");
#else
- UBCINFOEXISTS(vp) ?
- sprintf(buf, "holdcnt %d", vp->v_ubcinfo->ui_holdcnt),buf : "");
+ printf("holdcnt %d", vp->v_ubcinfo->ui_holdcnt);
#endif
+ } else printf("does not exist");
+ }
printf("\n");
return 0;
}
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/DUX/osi_vnodeops.c,v 1.1.1.6 2002/05/10 23:43:41 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/DUX/osi_vnodeops.c,v 1.1.1.7 2002/09/26 18:58:07 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
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 */
+ osi_FlushPages(avc, cred); /* hold bozon lock, but not basic vnode lock */
ObtainWriteLock(&avc->lock,162);
/* adjust parameters when appending files */
if ((ioflag & IO_APPEND) && uio->uio_rw == UIO_WRITE)
return code;
}
afs_BozonLock(&avc->pvnLock, avc);
- osi_FlushPages(avc); /* ensure old pages are gone */
+ osi_FlushPages(avc, cred); /* ensure old pages are gone */
afs_BozonUnlock(&avc->pvnLock, avc);
ObtainWriteLock(&avc->lock,166);
avc->states |= CMAPPED;
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_file.c,v 1.1.1.4 2001/09/11 14:24:57 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_file.c,v 1.1.1.5 2002/09/26 18:58:08 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
osi_FreeSmallSpace(afile);
osi_Panic("UFSOpen: igetinode failed");
}
- IN_UNLOCK(ip);
afile->vnode = ITOV(ip);
+ VOP_UNLOCK(afile->vnode, 0, curproc);
afile->size = VTOI(afile->vnode)->i_size;
afile->offset = 0;
afile->proc = (int (*)()) 0;
AFS_STATCNT(osi_Stat);
MObtainWriteLock(&afs_xosi,320);
AFS_GUNLOCK();
- VOP_GETATTR(afile->vnode, &tvattr, &afs_osi_cred, code);
+ code=VOP_GETATTR(afile->vnode, &tvattr, &afs_osi_cred, curproc);
AFS_GLOCK();
if (code == 0) {
astat->size = tvattr.va_size;
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;
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);
+ code=VOP_SETATTR(afile->vnode, &tvattr, &afs_osi_cred, curproc);
AFS_GLOCK();
- curproc->p_cred->pc_ucred = oldCred; /* restore */
MReleaseWriteLock(&afs_xosi);
return code;
}
struct vnode *avp;
{
struct inode *ip = VTOI(avp);
- ip->i_flag &= ~IACC;
+ ip->i_flag &= ~IN_ACCESS;
}
int offset;
char *aptr;
afs_int32 asize; {
- struct AFS_UCRED *oldCred;
unsigned int resid;
register afs_int32 code;
register afs_int32 cnt1=0;
char *aptr;
afs_int32 offset;
afs_int32 asize; {
- struct AFS_UCRED *oldCred;
unsigned int resid;
register afs_int32 code;
AFS_STATCNT(osi_Write);
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;
* 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
*
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_groups.c,v 1.1.1.3 2001/07/14 22:20:03 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_groups.c,v 1.1.1.4 2002/09/26 18:58:08 hartmans Exp $");
#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 code = 0;
struct vrequest treq;
+ struct ucred *cr;
+
+ cr=crdup(p->p_cred->pc_ucred);
AFS_STATCNT(afs_xsetgroups);
AFS_GLOCK();
-
- /* code = afs_InitReq(&treq, u.u_cred); */
- code = afs_InitReq(&treq, curproc->p_cred->pc_ucred);
+
+ code = afs_InitReq(&treq, cr);
AFS_GUNLOCK();
- if (code) return code;
+ crfree(cr);
+ if (code) return setgroups(p, args, retval); /* afs has shut down */
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) {
+ cr=crdup(p->p_cred->pc_ucred);
+
+ if (PagInCred(cr) == 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);
+ AddPag(p, treq.uid, &cr );
AFS_GUNLOCK();
}
}
+ crfree(cr);
return code;
}
AFS_STATCNT(setpag);
ngroups = afs_getgroups(*cred, NGROUPS, gidset);
- if (afs_get_pag_from_groups(gidset[0], gidset[1]) == NOPAG) {
+ if (afs_get_pag_from_groups(gidset[1], gidset[2]) == 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];
- }
+ for (j = ngroups -1; j >= 1; j--) {
+ gidset[j+2] = gidset[j];
+ }
ngroups += 2;
}
*newpag = (pagvalue == -1 ? genpag(): pagvalue);
- afs_get_groups_from_pag(*newpag, &gidset[0], &gidset[1]);
+ afs_get_groups_from_pag(*newpag, &gidset[1], &gidset[2]);
code = afs_setgroups(proc, cred, ngroups, gidset, change_parent);
return code;
}
int ngrps;
int i;
gid_t *gp;
- struct ucred *newcr, *cr;
+ struct ucred *oldcr, *cr;
AFS_STATCNT(afs_setgroups);
/*
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;
+ cr->cr_ngroups = ngroups;
+ gp = cr->cr_groups;
while (ngroups--)
*gp++ = *gidset++;
- if (!change_parent) {
- substitute_real_creds(proc, NOUID, NOUID, NOGID, NOGID, newcr);
+ if (change_parent) {
+ crhold(cr);
+ oldcr=proc->p_pptr->p_cred->pc_ucred;
+ proc->p_pptr->p_cred->pc_ucred=cr;
+ crfree(oldcr);
}
- *cred = newcr;
+ crhold(cr);
+ oldcr=proc->p_cred->pc_ucred;
+ proc->p_cred->pc_ucred=cr;
+ crfree(oldcr);
return(0);
}
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_inode.c,v 1.1.1.3 2001/07/14 22:20:04 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_inode.c,v 1.1.1.4 2002/09/26 18:58:08 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
ino_t inode;
int *perror;
{
- register struct vnode *vp;
- char fake_vnode[FAKE_INODE_SIZE];
- struct inode *ip;
+ struct vnode *vp;
int code;
*ipp = 0;
*perror = 0;
if (!fs) {
register struct ufsmount *ump;
- register struct vnode *vp;
register struct mount *mp;
- MOUNTLIST_LOCK();
+ simple_lock(&mountlist_slock);
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();
+ simple_unlock(&mountlist_slock);
if (!fs)
return(ENXIO);
}
- vp = (struct vnode *) fake_vnode;
- fake_inode_init(vp, fs);
- code = iget(VTOI(vp), inode, &ip, 0);
+ code = VFS_VGET(fs,inode, &vp);
if (code != 0) {
*perror = BAD_IGET;
return code;
} else {
- *ipp = ip;
+ *ipp = VTOI(vp);
return(0);
}
}
if (ip->i_mode == 0) {
/* Not an allocated inode */
- iforget(ip);
+ vput(ITOV(ip));
return(ENOENT);
}
if (ip->i_nlink == 0 || (ip->i_mode&IFMT) != IFREG) {
- iput(ip);
+ vput(ITOV(ip));
return(ENOENT);
}
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);
- }
-}
-
+#if 0
/*
* icreate system call -- create an inode
*/
iput(ip);
return(0);
}
+#else
+afs_syscall_icreate(dev, near_inode, param1, param2, param3, param4, retval)
+ long *retval;
+ long dev, near_inode, param1, param2, param3, param4;
+{
+ return EOPNOTSUPP;
+}
+afs_syscall_iopen(dev, inode, usrmod, retval)
+ long *retval;
+ int dev, inode, usrmod;
+{
+ return EOPNOTSUPP;
+}
+afs_syscall_iincdec(dev, inode, inode_p1, amount)
+ int dev, inode, inode_p1, amount;
+{
+ return EOPNOTSUPP;
+}
+#endif
+
/*
*
- * DUX OSI header file. Extends afs_osi.h.
+ * FBSD 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
#define _OSI_MACHDEP_H_
#include <sys/lock.h>
+#include <sys/time.h>
/* #include <kern/sched_prim.h> */
/* #include <sys/unix_defs.h> */
/*
* Time related macros
*/
-extern struct timeval time;
-#define osi_Time() (time.tv_sec)
+#define osi_Time() time_second
#define afs_hz hz
#define PAGESIZE 8192
#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 osi_vnhold(avc,r) do { VN_HOLD((struct vnode *)(avc)); } 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 gop_lookupname
+#define gop_lookupname osi_lookupname
#undef afs_suser
#ifdef KERNEL
-extern struct simplelock afs_global_lock;
-#if 0
-extern thread_t afs_global_owner;
+extern struct proc * afs_global_owner;
+extern struct lock afs_global_lock;
#define AFS_GLOCK() \
do { \
- usimple_lock(&afs_global_lock); \
- osi_Assert(afs_global_owner == (thread_t)0); \
- afs_global_owner = current_thread(); \
+ osi_Assert(curproc); \
+ lockmgr(&afs_global_lock, LK_EXCLUSIVE, 0, curproc); \
+ osi_Assert(afs_global_owner == 0); \
+ afs_global_owner = curproc; \
} while (0)
#define AFS_GUNLOCK() \
do { \
- osi_Assert(afs_global_owner == current_thread()); \
- afs_global_owner = (thread_t)0; \
- usimple_unlock(&afs_global_lock); \
+ osi_Assert(curproc); \
+ osi_Assert(afs_global_owner == curproc); \
+ afs_global_owner = 0; \
+ lockmgr(&afs_global_lock, LK_RELEASE, 0, curproc); \
} 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 ISAFS_GLOCK() (afs_global_owner == curproc && curproc)
#define AFS_RXGLOCK()
#define AFS_RXGUNLOCK()
#define ISAFS_RXGLOCK() 1
#undef SPLVAR
-#define SPLVAR
+#define SPLVAR int splvar
#undef NETPRI
-#define NETPRI
+#define NETPRI splvar=splnet()
#undef USERPRI
-#define USERPRI
+#define USERPRI splx(splvar)
#endif /* KERNEL */
#endif /* _OSI_MACHDEP_H_ */
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_misc.c,v 1.1.1.3 2001/07/14 22:20:04 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_misc.c,v 1.1.1.4 2002/09/26 18:58:09 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
-
+#include <sys/namei.h>
/*
* afs_suser() returns true if the caller is superuser, false otherwise.
*
}
return(0);
}
+
+int osi_lookupname(char *aname, enum uio_seg seg, int followlink,
+ struct vnode **dirvpp, struct vnode **vpp)
+{
+ struct nameidata n;
+ int flags,error;
+ flags=0;
+ flags=LOCKLEAF;
+ if (followlink)
+ flags|=FOLLOW;
+ else
+ flags|=NOFOLLOW;
+/* if (dirvpp) flags|=WANTPARENT;*/ /* XXX LOCKPARENT? */
+ NDINIT(&n, LOOKUP, flags, seg, aname, curproc);
+ if (error=namei(&n))
+ return error;
+ *vpp=n.ni_vp;
+/*
+ if (dirvpp)
+ *dirvpp = n.ni_dvp;
+*/
+ /* should we do this? */
+ VOP_UNLOCK(n.ni_vp, 0, curproc);
+ NDFREE(&n, NDF_ONLY_PNBUF);
+ return 0;
+}
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_sleep.c,v 1.1.1.3 2001/07/14 22:20:03 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_sleep.c,v 1.1.1.4 2002/09/26 18:58:09 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
seq = evp->seq;
while (seq == evp->seq) {
AFS_ASSERT_GLOCK();
- assert_wait((vm_offset_t)(&evp->cond), 0);
AFS_GUNLOCK();
- thread_block();
+ tsleep(event, PVFS, "afs_osi_Sleep", 0);
AFS_GLOCK();
}
relevent(evp);
}
+int afs_osi_SleepSig(char *event)
+{
+ afs_osi_Sleep(event);
+ return 0;
+}
+
/* osi_TimedSleep
*
* Arguments:
int code = 0;
struct afs_event *evp;
int ticks;
-
+ int seq,prio;
+
ticks = ( ams * afs_hz )/1000;
evp = afs_getevent(event);
-
- assert_wait((vm_offset_t)(&evp->cond), aintok);
+ seq=evp->seq;
AFS_GUNLOCK();
- thread_set_timeout(ticks);
- thread_block();
+ if (aintok)
+ prio=PCATCH|PPAUSE;
+ else
+ prio=PVFS;
+ code=tsleep(event, prio, "afs_osi_TimedSleep", ticks);
AFS_GLOCK();
- /* if (current_thread()->wait_result != THREAD_AWAKENED)
- code = EINTR; */
-
+ if (seq == evp->seq)
+ code=EINTR;
relevent(evp);
return code;
}
evp = afs_getevent(event);
if (evp->refcount > 1) {
evp->seq++;
- thread_wakeup((vm_offset_t)(&evp->cond));
+ wakeup(event);
}
relevent(evp);
}
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- *
- * This software has been released under the terms of the IBM Public
- * License. For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * osi_vfsops.c for DUX
- */
#include <afsconfig.h>
-#include "../afs/param.h"
+#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_vfsops.c,v 1.1.1.5 2002/05/10 23:43:46 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_vfsops.c,v 1.1.1.6 2002/09/26 18:58:09 hartmans Exp $");
-#include "../afs/sysincludes.h" /* Standard vendor system headers */
-#include "../afs/afsincludes.h" /* Afs-based standard headers */
-#include "../afs/afs_stats.h" /* statistics stuff */
-#include <sys/types.h>
-#include <kern/mach_param.h>
-#include <sys/sysconfig.h>
-#include <sys/systm.h>
-#include <sys/resource.h>
-#include <sys/errno.h>
+#include <afs/sysincludes.h> /* Standard vendor system headers */
+#include <afs/afsincludes.h> /* Afs-based standard headers */
+#include <afs/afs_stats.h> /* statistics */
+#include <sys/malloc.h>
+#include <sys/namei.h>
#include <sys/conf.h>
-#include <machine/machlimits.h>
-
+#include <sys/syscall.h>
struct vcache *afs_globalVp = 0;
struct mount *afs_globalVFS = 0;
+int afs_pbuf_freecnt=-1;
+int
+afs_quotactl()
+{
+ return EOPNOTSUPP;
+}
-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
+afs_fhtovp(mp, fhp, vpp)
+struct mount *mp;
+struct fid *fhp;
+struct vnode **vpp;
+{
+ return (EINVAL);
+}
-int mp_afs_mount(struct mount *afsp,char * path, caddr_t data,
- struct nameidata *ndp)
+int
+afs_vptofh(vp, fhp)
+struct vnode *vp;
+struct fid *fhp;
{
- u_int size;
- fsid_t tfsid;
- struct mount *xmp, *getvfs();
- int code;
+ return (EINVAL);
+}
+
+int
+afs_start(mp, flags, p)
+struct mount *mp;
+int flags;
+struct proc *p;
+{
+ afs_pbuf_freecnt = nswbuf / 2 + 1;
+ return (0); /* nothing to do. ? */
+}
+
+int
+afs_mount(mp, path, data, ndp, p)
+register struct mount *mp;
+char *path;
+caddr_t data;
+struct nameidata *ndp;
+struct proc *p;
+{
+ /* ndp contains the mounted-from device. Just ignore it.
+ we also don't care about our proc struct. */
+ size_t size;
+ int error;
+
+ if (mp->mnt_flag & MNT_UPDATE)
+ return EINVAL;
AFS_GLOCK();
AFS_STATCNT(afs_mount);
return (EBUSY);
}
- afs_globalVFS = afsp;
- afsp->vfs_bsize = 8192;
-/*
- * Generate a unique afs mount i.d. ( see nfs_mount() ).
- */
- afsp->m_stat.f_fsid.val[0] = makedev(130, 0);
- afsp->m_stat.f_fsid.val[1] = MOUNT_AFS;
- AFSMNTID_LOCK();
- if (++afs_mntid == 0)
- ++afs_mntid;
- AFSMNTID_UNLOCK();
- BM(AFSMNTID_LOCK());
- tfsid.val[0] = makedev(130, afs_mntid);
- tfsid.val[1] = MOUNT_AFS;
- BM(AFSMNTID_UNLOCK());
-
- while (xmp = getvfs(&tfsid)) {
- UNMOUNT_READ_UNLOCK(xmp);
- tfsid.val[0]++;
- AFSMNTID_LOCK();
- afs_mntid++;
- AFSMNTID_UNLOCK();
- }
- if (major(tfsid.val[0]) != 130) {
- AFS_GUNLOCK();
- return (ENOENT);
- }
- afsp->m_stat.f_fsid.val[0] = tfsid.val[0];
-
- afsp->m_stat.f_mntonname = AFS_KALLOC(MNAMELEN);
- afsp->m_stat.f_mntfromname = AFS_KALLOC(MNAMELEN);
- if ( !afsp->m_stat.f_mntonname || !afsp->m_stat.f_mntfromname)
- panic("malloc failure in afs_mount\n");
-
- memset(afsp->m_stat.f_mntonname, 0, MNAMELEN);
- memset(afsp->m_stat.f_mntfromname, 0, MNAMELEN);
- AFS_COPYINSTR(path, (caddr_t)afsp->m_stat.f_mntonname, MNAMELEN, &size, code);
- memcpy(afsp->m_stat.f_mntfromname, "AFS", 4);
- AFS_GUNLOCK();
- (void) mp_afs_statfs(afsp);
- AFS_GLOCK();
- afs_vfsdev = afsp->m_stat.f_fsid.val[0];
-
-#ifndef AFS_NONFSTRANS
- /* Set up the xlator in case it wasn't done elsewhere */
- afs_xlatorinit_v2();
- afs_xlatorinit_v3();
-#endif
+ afs_globalVFS = mp;
+ mp->vfs_bsize = 8192;
+ vfs_getnewfsid(mp);
+ mp->mnt_stat.f_iosize=8192;
+
+ (void) copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN-1, &size);
+ memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
+ memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);
+ strcpy(mp->mnt_stat.f_mntfromname, "AFS");
+ /* null terminated string "AFS" will fit, just leave it be. */
+ strcpy(mp->mnt_stat.f_fstypename, "afs");
AFS_GUNLOCK();
+ (void) afs_statfs(mp, &mp->mnt_stat, p);
return 0;
}
-
-int mp_afs_unmount (struct mount *afsp, int flag)
+int
+afs_unmount(mp, flags, p)
+struct mount *mp;
+int flags;
+struct proc *p;
{
+
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);
+ return 0;
}
-int mp_afs_root (struct mount *afsp, struct vnode **avpp)
+int
+afs_root(struct mount *mp,
+ struct vnode **vpp)
{
- register afs_int32 code = 0;
+ int error;
struct vrequest treq;
register struct vcache *tvp=0;
+ struct proc *p=curproc;
+ struct ucred cr;
+ cr=*p->p_cred->pc_ucred;
AFS_GLOCK();
AFS_STATCNT(afs_root);
if (afs_globalVp && (afs_globalVp->states & CStatd)) {
tvp = afs_globalVp;
+ error=0;
} else {
- if (!(code = afs_InitReq(&treq, cred)) &&
- !(code = afs_CheckInit())) {
+
+ if (!(error = afs_InitReq(&treq, &cr)) &&
+ !(error = afs_CheckInit())) {
tvp = afs_GetVCache(&afs_rootFid, &treq, (afs_int32 *)0,
- (struct vcache*)0, WRITE_LOCK);
+ (struct vcache*)0, WRITE_LOCK);
/* we really want this to stay around */
if (tvp) {
- afs_globalVp = tvp;
+ afs_globalVp = tvp;
} else
- code = ENOENT;
+ error = ENOENT;
}
}
if (tvp) {
- AFS_GUNLOCK();
- VN_HOLD((struct vnode *)tvp);
- VN_LOCK(AFSTOV(tvp));
- tvp->v.v_flag |= VROOT; /* No-op on Ultrix 2.2 */
- VN_UNLOCK((struct vnode *)tvp);
- AFS_GLOCK();
-
- afs_globalVFS = afsp;
- *avpp = AFSTOV(tvp);
+ osi_vnhold(tvp,0);
+ AFS_GUNLOCK();
+ vn_lock(AFSTOV(tvp), LK_EXCLUSIVE | LK_RETRY, p);
+ AFS_GLOCK();
+ afs_globalVFS = mp;
+ *vpp = AFSTOV(tvp);
+ tvp->v.v_flag |= VROOT;
}
- afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *avpp,
- ICL_TYPE_INT32, code);
+ afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *vpp,
+ ICL_TYPE_INT32, error);
AFS_GUNLOCK();
- return code;
+ return error;
}
-
-mp_afs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg)
+int
+afs_vget(mp, lfl, vp)
+struct mount *mp;
+struct vnode *vp;
+int lfl;
{
- return EOPNOTSUPP;
+ int error;
+ printf("vget called. help!\n");
+ if (vp->v_usecount < 0) {
+ vprint("bad usecount", vp);
+ panic("afs_vget");
+ }
+ error = vget(vp, lfl, curproc);
+ if (!error)
+ insmntque(vp, afs_globalVFS); /* take off free list */
+ return error;
}
-int mp_afs_statfs(struct mount *afsp)
+int afs_statfs(struct mount *mp, struct statfs *abp, struct proc *p)
{
- struct nstatfs *abp = &afsp->m_stat;
-
AFS_GLOCK();
AFS_STATCNT(afs_statfs);
+#if 0
abp->f_type = MOUNT_AFS;
- abp->f_bsize = afsp->vfs_bsize;
+#endif
+ abp->f_bsize = mp->vfs_bsize;
+ abp->f_iosize = mp->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
*/
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);
+ abp->f_fsid.val[0] = mp->mnt_stat.f_fsid.val[0];
+ abp->f_fsid.val[1] = mp->mnt_stat.f_fsid.val[1];
+ if (abp != &mp->mnt_stat) {
+ abp->f_type = mp->mnt_vfc->vfc_typenum;
+ memcpy((caddr_t)&abp->f_mntonname[0], (caddr_t)mp->mnt_stat.f_mntonname, MNAMELEN);
+ memcpy((caddr_t)&abp->f_mntfromname[0], (caddr_t)mp->mnt_stat.f_mntfromname, MNAMELEN);
}
- 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) {
- memcpy(fidp->fid_data, (caddr_t)&Sfid, AFS_FIDDATASIZE);
- } else {
- memcpy(fidp->fid_data, (caddr_t)addr, AFS_FIDDATASIZE);
- }
- } else {
- memcpy(fidp->fid_data, (caddr_t)&Sfid, AFS_FIDDATASIZE);
- }
AFS_GUNLOCK();
return 0;
}
-
-int mp_Afs_init(void); /* vfs_init - defined below */
-
-
-/* This is only called by vfs_mount when afs is going to be mounted as root.
- * Since we don't support diskless clients we shouldn't come here.
- */
-int afsmountroot=0;
-int mp_afs_mountroot(struct mount *afsp, struct vnode **vp)
+int afs_sync(mp, waitfor, cred, p)
+struct mount *mp;
+int waitfor;
+struct ucred *cred;
+struct prioc *p;
{
- AFS_GLOCK();
- AFS_STATCNT(afs_mountroot);
- afsmountroot++;
- AFS_GUNLOCK();
- return EINVAL;
+return 0;
}
-
-/* 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;
+int afs_sysctl() {
+ return EOPNOTSUPP;
}
-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;
+int afs_init(struct vfsconf *vfc) {
+ return 0;
}
-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 */
+struct vfsops afs_vfsops = {
+ afs_mount,
+ afs_start,
+ afs_unmount,
+ afs_root,
+ afs_quotactl,
+ afs_statfs,
+ afs_sync,
+ afs_vget,
+ afs_fhtovp,
+ afs_vptofh,
+ afs_init,
+ afs_sysctl
};
-
-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;
-}
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_vm.c,v 1.1.1.4 2002/05/10 23:43:47 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_vm.c,v 1.1.1.5 2002/09/26 18:58:09 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
#include "../afs/afs_stats.h" /* statistics */
-/* #include <vm/vm_ubc.h> */
+#include <vm/vm_object.h>
+#include <vm/vm_map.h>
#include <limits.h>
#include <float.h>
struct vcache *avc;
int *slept;
{
-#ifdef SECRETLY_OSF1
- if (avc->vrefCount > 1)
+ struct vm_object *obj;
+ struct vnode *vp;
+ if (VREFCOUNT(avc) > 1)
return EBUSY;
if (avc->opens)
return EBUSY;
AFS_GUNLOCK();
- ubc_invalidate(((struct vnode *)avc)->v_object, 0, 0, B_INVAL);
+ vp=avc;
+ simple_lock(&vp->v_interlock);
+ if (VOP_GETVOBJECT(vp, &obj) == 0) {
+ vm_object_page_remove(obj, 0, 0, FALSE);
+#if 0
+ if (obj->ref_count == 0) {
+ vgonel(vp,curproc);
+ simple_lock(&vp->v_interlock);
+ vp->v_tag=VT_AFS;
+ SetAfsVnode(vp);
+ }
+#endif
+ }
+ simple_unlock(&vp->v_interlock);
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
osi_VM_StoreAllSegments(avc)
struct vcache *avc;
{
-#ifdef SECRETLY_OSF1
+ struct vnode *vp;
+ struct vm_object *obj;
+ int anyio,tries;
ReleaseWriteLock(&avc->lock);
AFS_GUNLOCK();
- osi_ubc_flush_dirty_and_wait((struct vnode *)avc, 0);
+ tries=5;
+ vp=avc;
+ do {
+ anyio=0;
+ simple_lock(&vp->v_interlock);
+ if (VOP_GETVOBJECT(vp, &obj) == 0 &&
+ (obj->flags & OBJ_MIGHTBEDIRTY)) {
+ if (!vget(vp,
+ LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY | LK_NOOBJ, curproc)) {
+ if (VOP_GETVOBJECT(vp, &obj) == 0) {
+ vm_object_page_clean(obj, 0, 0, OBJPC_SYNC);
+ anyio = 1;
+ }
+ vput(vp);
+ }
+ } else {
+ simple_unlock(&vp->v_interlock);
+ }
+ } while (anyio && (--tries > 0));
AFS_GLOCK();
ObtainWriteLock(&avc->lock,94);
-#endif /* SECRETLY_OSF1 */
}
/* Try to invalidate pages, for "fs flush" or "fs flushv"; or
struct AFS_UCRED *acred;
int sync;
{
-#ifdef SECRETLY_OSF1
+ struct vnode *vp;
+ struct vm_object *obj;
+ int anyio, tries;
ReleaseWriteLock(&avc->lock);
AFS_GUNLOCK();
- osi_ubc_flush_dirty_and_wait(AFSTOV(avc), 0);
- ubc_invalidate((AFSTOV(avc))->v_object, 0, 0, B_INVAL);
+ tries=5;
+ vp=avc;
+ do {
+ anyio=0;
+ simple_lock(&vp->v_interlock);
+ if (VOP_GETVOBJECT(vp, &obj) == 0 &&
+ (obj->flags & OBJ_MIGHTBEDIRTY)) {
+ if (!vget(vp,
+ LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY | LK_NOOBJ, curproc)) {
+ if (VOP_GETVOBJECT(vp, &obj) == 0) {
+ vm_object_page_clean(obj, 0, 0, OBJPC_SYNC);
+ anyio = 1;
+ }
+ vput(vp);
+ }
+ } else {
+ simple_unlock(&vp->v_interlock);
+ }
+ } while (anyio && (--tries > 0));
+ simple_lock(&vp->v_interlock);
+ if (VOP_GETVOBJECT(vp, &obj) == 0) {
+ vm_object_page_remove(obj, 0, 0, FALSE);
+ }
+ simple_unlock(&vp->v_interlock);
+ /*vinvalbuf(AFSTOV(avc),0, NOCRED, curproc, 0,0);*/
AFS_GLOCK();
ObtainWriteLock(&avc->lock,59);
-#endif /* SECRETLY_OSF1 */
}
/* Purge VM for a file when its callback is revoked.
struct vcache *avc;
struct AFS_UCRED *credp;
{
-#ifdef SECRETLY_OSF1
- ubc_flush_dirty((AFSTOV(avc))->v_object, 0);
- ubc_invalidate((AFSTOV(avc))->v_object, 0, 0, B_INVAL);
-#endif /* SECRETLY_OSF1 */
+ struct vnode *vp;
+ struct vm_object *obj;
+ vp=avc;
+ simple_lock(&vp->v_interlock);
+ if (VOP_GETVOBJECT(vp, &obj) == 0) {
+ vm_object_page_remove(obj, 0, 0, FALSE);
+ }
+ simple_unlock(&vp->v_interlock);
+ /*vinvalbuf(AFSTOV(avc),0, NOCRED, curproc, 0,0);*/
}
/* Purge pages beyond end-of-file, when truncating a file.
int alen;
struct AFS_UCRED *acred;
{
-#ifdef SECRETLY_OSF1
- ubc_invalidate((AFSTOV(avc))->v_object, alen,
- MAXINT - alen, B_INVAL);
-#endif /* SECRETLY_OSF1 */
+ vnode_pager_setsize(AFSTOV(avc), alen);
}
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- *
- * This software has been released under the terms of the IBM Public
- * License. For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-/*
- * vnodeops structure and Digital Unix specific ops and support routines.
- */
-
#include <afsconfig.h>
-#include "../afs/param.h"
-
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_vnodeops.c,v 1.1.1.3 2001/07/14 22:20:04 hartmans Exp $");
+#include <afs/param.h>
+
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/FBSD/osi_vnodeops.c,v 1.1.1.4 2002/09/26 18:58:10 hartmans Exp $");
+
+#include <afs/sysincludes.h> /* Standard vendor system headers */
+#include <afs/afsincludes.h> /* Afs-based standard headers */
+#include <afs/afs_stats.h> /* statistics */
+#include <sys/malloc.h>
+#include <sys/namei.h>
+#include <vm/vm_zone.h>
+#include <vm/vm_page.h>
+#include <vm/vm_object.h>
+#include <vm/vm_pager.h>
+#include <vm/vnode_pager.h>
+extern int afs_pbuf_freecnt;
+
+int afs_vop_lookup(struct vop_lookup_args *);
+int afs_vop_create(struct vop_create_args *);
+int afs_vop_mknod(struct vop_mknod_args *);
+int afs_vop_open(struct vop_open_args *);
+int afs_vop_close(struct vop_close_args *);
+int afs_vop_access(struct vop_access_args *);
+int afs_vop_getattr(struct vop_getattr_args *);
+int afs_vop_setattr(struct vop_setattr_args *);
+int afs_vop_read(struct vop_read_args *);
+int afs_vop_write(struct vop_write_args *);
+int afs_vop_getpages(struct vop_getpages_args *);
+int afs_vop_putpages(struct vop_putpages_args *);
+int afs_vop_ioctl(struct vop_ioctl_args *);
+int afs_vop_poll(struct vop_poll_args *);
+int afs_vop_mmap(struct vop_mmap_args *);
+int afs_vop_fsync(struct vop_fsync_args *);
+int afs_vop_remove(struct vop_remove_args *);
+int afs_vop_link(struct vop_link_args *);
+int afs_vop_rename(struct vop_rename_args *);
+int afs_vop_mkdir(struct vop_mkdir_args *);
+int afs_vop_rmdir(struct vop_rmdir_args *);
+int afs_vop_symlink(struct vop_symlink_args *);
+int afs_vop_readdir(struct vop_readdir_args *);
+int afs_vop_readlink(struct vop_readlink_args *);
+int afs_vop_inactive(struct vop_inactive_args *);
+int afs_vop_reclaim(struct vop_reclaim_args *);
+int afs_vop_lock(struct vop_lock_args *);
+int afs_vop_unlock(struct vop_unlock_args *);
+int afs_vop_bmap(struct vop_bmap_args *);
+int afs_vop_strategy(struct vop_strategy_args *);
+int afs_vop_print(struct vop_print_args *);
+int afs_vop_islocked(struct vop_islocked_args *);
+int afs_vop_advlock(struct vop_advlock_args *);
+
+
+
+/* Global vfs data structures for AFS. */
+vop_t **afs_vnodeop_p;
+struct vnodeopv_entry_desc afs_vnodeop_entries[] = {
+ { &vop_default_desc, (vop_t *) vop_eopnotsupp },
+ { &vop_access_desc, (vop_t *) afs_vop_access }, /* access */
+ { &vop_advlock_desc, (vop_t *) afs_vop_advlock }, /* advlock */
+ { &vop_bmap_desc, (vop_t *) afs_vop_bmap }, /* bmap */
+ { &vop_bwrite_desc, (vop_t *) vop_stdbwrite },
+ { &vop_close_desc, (vop_t *) afs_vop_close }, /* close */
+ { &vop_createvobject_desc, (vop_t *) vop_stdcreatevobject },
+ { &vop_destroyvobject_desc, (vop_t *) vop_stddestroyvobject },
+ { &vop_create_desc, (vop_t *) afs_vop_create }, /* create */
+ { &vop_fsync_desc, (vop_t *) afs_vop_fsync }, /* fsync */
+ { &vop_getattr_desc, (vop_t *) afs_vop_getattr }, /* getattr */
+ { &vop_getpages_desc, (vop_t *) afs_vop_getpages }, /* read */
+ { &vop_getvobject_desc, (vop_t *) vop_stdgetvobject },
+ { &vop_putpages_desc, (vop_t *) afs_vop_putpages }, /* write */
+ { &vop_inactive_desc, (vop_t *) afs_vop_inactive }, /* inactive */
+ { &vop_islocked_desc, (vop_t *) afs_vop_islocked }, /* islocked */
+ { &vop_lease_desc, (vop_t *) vop_null },
+ { &vop_link_desc, (vop_t *) afs_vop_link }, /* link */
+ { &vop_lock_desc, (vop_t *) afs_vop_lock }, /* lock */
+ { &vop_lookup_desc, (vop_t *) afs_vop_lookup }, /* lookup */
+ { &vop_mkdir_desc, (vop_t *) afs_vop_mkdir }, /* mkdir */
+ { &vop_mknod_desc, (vop_t *) afs_vop_mknod }, /* mknod */
+ { &vop_mmap_desc, (vop_t *) afs_vop_mmap }, /* mmap */
+ { &vop_open_desc, (vop_t *) afs_vop_open }, /* open */
+ { &vop_poll_desc, (vop_t *) afs_vop_poll }, /* select */
+ { &vop_print_desc, (vop_t *) afs_vop_print }, /* print */
+ { &vop_read_desc, (vop_t *) afs_vop_read }, /* read */
+ { &vop_readdir_desc, (vop_t *) afs_vop_readdir }, /* readdir */
+ { &vop_readlink_desc, (vop_t *) afs_vop_readlink }, /* readlink */
+ { &vop_reclaim_desc, (vop_t *) afs_vop_reclaim }, /* reclaim */
+ { &vop_remove_desc, (vop_t *) afs_vop_remove }, /* remove */
+ { &vop_rename_desc, (vop_t *) afs_vop_rename }, /* rename */
+ { &vop_rmdir_desc, (vop_t *) afs_vop_rmdir }, /* rmdir */
+ { &vop_setattr_desc, (vop_t *) afs_vop_setattr }, /* setattr */
+ { &vop_strategy_desc, (vop_t *) afs_vop_strategy }, /* strategy */
+ { &vop_symlink_desc, (vop_t *) afs_vop_symlink }, /* symlink */
+ { &vop_unlock_desc, (vop_t *) afs_vop_unlock }, /* unlock */
+ { &vop_write_desc, (vop_t *) afs_vop_write }, /* write */
+ { &vop_ioctl_desc, (vop_t *) afs_vop_ioctl }, /* XXX ioctl */
+ /*{ &vop_seek_desc, afs_vop_seek },*/ /* seek */
+ { NULL, NULL }
+};
+struct vnodeopv_desc afs_vnodeop_opv_desc =
+ { &afs_vnodeop_p, afs_vnodeop_entries };
+#define GETNAME() \
+ struct componentname *cnp = ap->a_cnp; \
+ char *name; \
+ MALLOC(name, char *, cnp->cn_namelen+1, M_TEMP, M_WAITOK); \
+ memcpy(name, cnp->cn_nameptr, cnp->cn_namelen); \
+ name[cnp->cn_namelen] = '\0'
-#include "../afs/sysincludes.h" /* Standard vendor system headers */
-#include "../afs/afsincludes.h" /* Afs-based standard headers */
-#include "../afs/afs_stats.h" /* statistics */
-#include <vm/vm.h>
-#include <vm/vnode_pager.h>
-#include <vm/vm_map.h>
-/* #include <vm/vm_ubc.h> */
-#include "../afs/afs_cbqueue.h"
-#include "../afs/nfsclient.h"
-#include "../afs/afs_osidnlc.h"
-
-
-extern int afs_lookup(), afs_create(), afs_noop(), afs_open(), afs_close();
-extern int afs_access(), afs_getattr(), afs_setattr(), afs_badop();
-extern int afs_fsync(), afs_seek(), afs_remove(), afs_link(), afs_rename();
-extern int afs_mkdir(), afs_rmdir(), afs_symlink(), afs_readdir();
-extern int afs_readlink(), afs_lockctl();
-extern int vn_pathconf_default(), seltrue();
-
-int mp_afs_lookup(), mp_afs_create(), mp_afs_open();
-int mp_afs_access(), mp_afs_getattr(), mp_afs_setattr(), mp_afs_ubcrdwr();
-int mp_afs_ubcrdwr(), mp_afs_mmap();
-int mp_afs_fsync(), mp_afs_seek(), mp_afs_remove(), mp_afs_link();
-int mp_afs_rename(), mp_afs_mkdir(), mp_afs_rmdir(), mp_afs_symlink();
-int mp_afs_readdir(), mp_afs_readlink(), mp_afs_abortop(), mp_afs_inactive();
-int mp_afs_reclaim(), mp_afs_bmap(), mp_afs_strategy(), mp_afs_print();
-int mp_afs_page_read(), mp_afs_page_write(), mp_afs_swap(), mp_afs_bread();
-int mp_afs_brelse(), mp_afs_lockctl(), mp_afs_syncdata(), mp_afs_close();
-int mp_afs_closex();
+#define DROPNAME() FREE(name, M_TEMP)
+
-#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
+afs_vop_lookup(ap)
+struct vop_lookup_args /* {
+ struct vnodeop_desc * a_desc;
+ struct vnode *a_dvp;
+ struct vnode **a_vpp;
+ struct componentname *a_cnp;
+ } */ *ap;
{
- int code;
+ int error;
+ struct vcache *vcp;
+ struct vnode *vp, *dvp;
+ register int flags = ap->a_cnp->cn_flags;
+ int lockparent; /* 1 => lockparent flag is set */
+ int wantparent; /* 1 => wantparent or lockparent flag */
+ struct proc *p;
+ GETNAME();
+ p=cnp->cn_proc;
+ lockparent = flags & LOCKPARENT;
+ wantparent = flags & (LOCKPARENT|WANTPARENT);
+
+ if (ap->a_dvp->v_type != VDIR) {
+ *ap->a_vpp = 0;
+ DROPNAME();
+ return ENOTDIR;
+ }
+ dvp = ap->a_dvp;
+ if (flags & ISDOTDOT)
+ VOP_UNLOCK(dvp, 0, p);
AFS_GLOCK();
- code = afs_lookup(adp, ndp);
+ error = afs_lookup(VTOAFS(dvp), name, &vcp, cnp->cn_cred);
AFS_GUNLOCK();
- return code;
-}
+ if (error) {
+ if (flags & ISDOTDOT)
+ VOP_LOCK(dvp, LK_EXCLUSIVE | LK_RETRY, p);
+ if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
+ (flags & ISLASTCN) && error == ENOENT)
+ error = EJUSTRETURN;
+ if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
+ cnp->cn_flags |= SAVENAME;
+ DROPNAME();
+ *ap->a_vpp = 0;
+ return (error);
+ }
+ vp = AFSTOV(vcp); /* always get a node if no error */
+
+ /* The parent directory comes in locked. We unlock it on return
+ unless the caller wants it left locked.
+ we also always return the vnode locked. */
+
+ if (flags & ISDOTDOT) {
+ vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+ /* always return the child locked */
+ if (lockparent && (flags & ISLASTCN) &&
+ (error = vn_lock(dvp, LK_EXCLUSIVE, p))) {
+ vput(vp);
+ DROPNAME();
+ return (error);
+ }
+ } else if (vp == dvp) {
+ /* they're the same; afs_lookup() already ref'ed the leaf.
+ It came in locked, so we don't need to ref OR lock it */
+ } else {
+ if (!lockparent || !(flags & ISLASTCN))
+ VOP_UNLOCK(dvp, 0, p); /* done with parent. */
+ vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+ /* always return the child locked */
+ }
+ *ap->a_vpp = vp;
-mp_afs_create(ndp, attrs)
- struct nameidata *ndp;
- struct vattr *attrs;
-{
- int code;
- AFS_GLOCK();
- code = afs_create(ndp, attrs);
- AFS_GUNLOCK();
- return code;
-}
+ if ((cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN)) ||
+ (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN)))
+ cnp->cn_flags |= SAVENAME;
-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;
+ DROPNAME();
+ return error;
}
-mp_afs_access(avc, amode, acred)
- struct vcache *avc;
- afs_int32 amode;
- struct AFS_UCRED *acred;
+int
+afs_vop_create(ap)
+ struct vop_create_args /* {
+ struct vnode *a_dvp;
+ struct vnode **a_vpp;
+ struct componentname *a_cnp;
+ struct vattr *a_vap;
+ } */ *ap;
{
- int code;
- AFS_GLOCK();
- code = afs_access(avc, amode, acred);
- AFS_GUNLOCK();
- return code;
-}
+ int error = 0;
+ struct vcache *vcp;
+ register struct vnode *dvp = ap->a_dvp;
+ struct proc *p;
+ GETNAME();
+ p=cnp->cn_proc;
-mp_afs_close(avc, flags, cred)
- struct vnode *avc;
- int flags;
- struct ucred *cred;
-{
- int code;
AFS_GLOCK();
- code = afs_close(avc, flags, cred);
+ error = afs_create(VTOAFS(dvp), name, ap->a_vap, ap->a_vap->va_vaflags & VA_EXCLUSIVE? EXCL : NONEXCL,
+ ap->a_vap->va_mode, &vcp,
+ cnp->cn_cred);
AFS_GUNLOCK();
- return code;
-}
+ if (error) {
+ DROPNAME();
+ return(error);
+ }
-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;
-}
+ if (vcp) {
+ *ap->a_vpp = AFSTOV(vcp);
+ vn_lock(AFSTOV(vcp), LK_EXCLUSIVE| LK_RETRY, p);
+ }
+ else *ap->a_vpp = 0;
-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;
+ DROPNAME();
+ return error;
}
-mp_afs_fsync(avc, fflags, acred, waitfor)
- struct vcache *avc;
- int fflags;
- struct AFS_UCRED *acred;
- int waitfor;
+int
+afs_vop_mknod(ap)
+ struct vop_mknod_args /* {
+ struct vnode *a_dvp;
+ struct vnode **a_vpp;
+ struct componentname *a_cnp;
+ struct vattr *a_vap;
+ } */ *ap;
{
- int code;
- AFS_GLOCK();
- code = afs_fsync(avc, fflags, acred, waitfor);
- AFS_GUNLOCK();
- return code;
+ return(ENODEV);
}
-mp_afs_remove(ndp)
- struct nameidata *ndp;
+#if 0
+static int validate_vops(struct vnode *vp, int after)
{
- int code;
- AFS_GLOCK();
- code = afs_remove(ndp);
- AFS_GUNLOCK();
- return code;
-}
-
-mp_afs_link(avc, ndp)
- struct vcache *avc;
- struct nameidata *ndp;
+ int ret=0;
+ struct vnodeopv_entry_desc *this;
+ for (this=afs_vnodeop_entries; this->opve_op; this++) {
+ if (vp->v_op[this->opve_op->vdesc_offset] != this->opve_impl) {
+ if (!ret) {
+ printf("v_op %d ", after);
+ vprint("check", vp);
+ }
+ ret=1;
+ printf("For oper %d (%s), func is %p, not %p",
+ this->opve_op->vdesc_offset, this->opve_op->vdesc_name,
+ vp->v_op[this->opve_op->vdesc_offset], this->opve_impl);
+ }
+ }
+ return ret;
+}
+#endif
+int
+afs_vop_open(ap)
+ struct vop_open_args /* {
+ struct vnode *a_vp;
+ int a_mode;
+ struct ucred *a_cred;
+ struct proc *a_p;
+ } */ *ap;
{
- int code;
+ int error;
+ int bad;
+ struct vcache *vc = VTOAFS(ap->a_vp);
+ bad=0;
AFS_GLOCK();
- code = afs_link(avc, ndp);
+ error = afs_open(&vc, ap->a_mode, ap->a_cred);
+#ifdef DIAGNOSTIC
+ if (AFSTOV(vc) != ap->a_vp)
+ panic("AFS open changed vnode!");
+#endif
+ afs_BozonLock(&vc->pvnLock, vc);
+ osi_FlushPages(vc);
+ afs_BozonUnlock(&vc->pvnLock, vc);
AFS_GUNLOCK();
- return code;
+ return error;
}
-mp_afs_rename(fndp, tndp)
- struct nameidata *fndp, *tndp;
+int
+afs_vop_close(ap)
+ struct vop_close_args /* {
+ struct vnode *a_vp;
+ int a_fflag;
+ struct ucred *a_cred;
+ struct proc *a_p;
+ } */ *ap;
{
int code;
+ struct vcache *avc=ap->a_vp;
AFS_GLOCK();
- code = afs_rename(fndp, tndp);
+ if (ap->a_cred)
+ code=afs_close(avc, ap->a_fflag, ap->a_cred, ap->a_p);
+ else
+ code=afs_close(avc, ap->a_fflag, &afs_osi_cred, ap->a_p);
+ afs_BozonLock(&avc->pvnLock, avc);
+ osi_FlushPages(avc); /* hold bozon lock, but not basic vnode lock */
+ afs_BozonUnlock(&avc->pvnLock, avc);
AFS_GUNLOCK();
return code;
}
-mp_afs_mkdir(ndp, attrs)
- struct nameidata *ndp;
- struct vattr *attrs;
+int
+afs_vop_access(ap)
+ struct vop_access_args /* {
+ struct vnode *a_vp;
+ int a_mode;
+ struct ucred *a_cred;
+ struct proc *a_p;
+ } */ *ap;
{
int code;
AFS_GLOCK();
- code = afs_mkdir(ndp, attrs);
+ code=afs_access(VTOAFS(ap->a_vp), ap->a_mode, ap->a_cred);
AFS_GUNLOCK();
return code;
}
-
-mp_afs_rmdir(ndp)
- struct nameidata *ndp;
+int
+afs_vop_getattr(ap)
+ struct vop_getattr_args /* {
+ struct vnode *a_vp;
+ struct vattr *a_vap;
+ struct ucred *a_cred;
+ struct proc *a_p;
+ } */ *ap;
{
int code;
AFS_GLOCK();
- code = afs_rmdir(ndp);
+ code=afs_getattr(VTOAFS(ap->a_vp), ap->a_vap, ap->a_cred);
AFS_GUNLOCK();
return code;
}
-
-mp_afs_symlink(ndp, attrs, atargetName)
- struct nameidata *ndp;
- struct vattr *attrs;
- register char *atargetName;
+int
+afs_vop_setattr(ap)
+ struct vop_setattr_args /* {
+ struct vnode *a_vp;
+ struct vattr *a_vap;
+ struct ucred *a_cred;
+ struct proc *a_p;
+ } */ *ap;
{
int code;
AFS_GLOCK();
- code = afs_symlink(ndp, attrs, atargetName);
+ code=afs_setattr(VTOAFS(ap->a_vp), ap->a_vap, ap->a_cred);
AFS_GUNLOCK();
return code;
-}
-
-mp_afs_readdir(avc, auio, acred, eofp)
- struct vcache *avc;
- struct uio *auio;
- struct AFS_UCRED *acred;
- int *eofp;
+}int
+afs_vop_read(ap)
+ struct vop_read_args /* {
+ struct vnode *a_vp;
+ struct uio *a_uio;
+ int a_ioflag;
+ struct ucred *a_cred;
+
+} */ *ap;
{
int code;
+ struct vcache *avc=VTOAFS(ap->a_vp);
AFS_GLOCK();
- code = afs_readdir(avc, auio, acred, eofp);
+ afs_BozonLock(&avc->pvnLock, avc);
+ osi_FlushPages(avc); /* hold bozon lock, but not basic vnode lock */
+ code=afs_read(avc, ap->a_uio, ap->a_cred, 0, 0, 0);
+ afs_BozonUnlock(&avc->pvnLock, avc);
AFS_GUNLOCK();
return code;
}
-
-mp_afs_readlink(avc, auio, acred)
- struct vcache *avc;
- struct uio *auio;
- struct AFS_UCRED *acred;
+int
+afs_vop_getpages(ap)
+ struct vop_getpages_args /* {
+ struct vnode *a_vp;
+ vm_page_t *a_m;
+ int a_count;
+ int a_reqpage;
+ vm_oofset_t a_offset;
+ } */ *ap;
{
int code;
+ int i, nextoff, size, toff, npages;
+ struct uio uio;
+ struct iovec iov;
+ struct buf *bp;
+ vm_offset_t kva;
+ struct vcache *avc=VTOAFS(ap->a_vp);
+
+ if (avc->v.v_object == NULL) {
+ printf("afs_getpages: called with non-merged cache vnode??\n");
+ return VM_PAGER_ERROR;
+ }
+ npages=btoc(ap->a_count);
+ /*
+ * If the requested page is partially valid, just return it and
+ * allow the pager to zero-out the blanks. Partially valid pages
+ * can only occur at the file EOF.
+ */
+
+ {
+ vm_page_t m = ap->a_m[ap->a_reqpage];
+
+ if (m->valid != 0) {
+ /* handled by vm_fault now */
+ /* vm_page_zero_invalid(m, TRUE); */
+ for (i = 0; i < npages; ++i) {
+ if (i != ap->a_reqpage)
+ vnode_pager_freepage(ap->a_m[i]);
+ }
+ return(0);
+ }
+ }
+ bp = getpbuf(&afs_pbuf_freecnt);
+ kva = (vm_offset_t) bp->b_data;
+ pmap_qenter(kva, ap->a_m, npages);
+ iov.iov_base=(caddr_t)kva;
+ iov.iov_len=ap->a_count;
+ uio.uio_iov=&iov;
+ uio.uio_iovcnt=1;
+ uio.uio_offset=IDX_TO_OFF(ap->a_m[0]->pindex);
+ uio.uio_resid=ap->a_count;
+ uio.uio_segflg=UIO_SYSSPACE;
+ uio.uio_rw=UIO_READ;
+ uio.uio_procp=curproc;
AFS_GLOCK();
- code = afs_readlink(avc, auio, acred);
+ afs_BozonLock(&avc->pvnLock, avc);
+ osi_FlushPages(avc); /* hold bozon lock, but not basic vnode lock */
+ code=afs_read(avc, &uio, curproc->p_cred->pc_ucred, 0, 0, 0);
+ afs_BozonUnlock(&avc->pvnLock, avc);
AFS_GUNLOCK();
- return code;
+ pmap_qremove(kva, npages);
+
+ relpbuf(bp, &afs_pbuf_freecnt);
+ if (code && (uio.uio_resid == ap->a_count)) {
+ for (i = 0; i < npages; ++i) {
+ if (i != ap->a_reqpage)
+ vnode_pager_freepage(ap->a_m[i]);
+ }
+ return VM_PAGER_ERROR;
+ }
+ size = ap->a_count - uio.uio_resid;
+ for (i = 0, toff = 0; i < npages; i++, toff = nextoff) {
+ vm_page_t m;
+ nextoff = toff + PAGE_SIZE;
+ m = ap->a_m[i];
+
+ m->flags &= ~PG_ZERO;
+
+ if (nextoff <= size) {
+ /*
+ * Read operation filled an entire page
+ */
+ m->valid = VM_PAGE_BITS_ALL;
+ vm_page_undirty(m);
+ } else if (size > toff) {
+ /*
+ * Read operation filled a partial page.
+ */
+ m->valid = 0;
+ vm_page_set_validclean(m, 0, size - toff);
+ /* handled by vm_fault now */
+ /* vm_page_zero_invalid(m, TRUE); */
+ }
+
+ if (i != ap->a_reqpage) {
+ /*
+ * Whether or not to leave the page activated is up in
+ * the air, but we should put the page on a page queue
+ * somewhere (it already is in the object). Result:
+ * It appears that emperical results show that
+ * deactivating pages is best.
+ */
+
+ /*
+ * Just in case someone was asking for this page we
+ * now tell them that it is ok to use.
+ */
+ if (!code) {
+ if (m->flags & PG_WANTED)
+ vm_page_activate(m);
+ else
+ vm_page_deactivate(m);
+ vm_page_wakeup(m);
+ } else {
+ vnode_pager_freepage(m);
+ }
+ }
+ }
+ return 0;
}
-
-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
+afs_vop_write(ap)
+ struct vop_write_args /* {
+ struct vnode *a_vp;
+ struct uio *a_uio;
+ int a_ioflag;
+ struct ucred *a_cred;
+ } */ *ap;
{
int code;
+ struct vcache *avc=VTOAFS(ap->a_vp);
AFS_GLOCK();
- code = afs_lockctl(avc, af, flag, acred, clid, offset);
+ afs_BozonLock(&avc->pvnLock, avc);
+ osi_FlushPages(avc); /* hold bozon lock, but not basic vnode lock */
+ code=afs_write(VTOAFS(ap->a_vp), ap->a_uio, ap->a_ioflag, ap->a_cred, 0);
+ afs_BozonUnlock(&avc->pvnLock, avc);
AFS_GUNLOCK();
return code;
}
-mp_afs_closex(afd)
- struct file *afd;
+int
+afs_vop_putpages(ap)
+ struct vop_putpages_args /* {
+ struct vnode *a_vp;
+ vm_page_t *a_m;
+ int a_count;
+ int a_sync;
+ int *a_rtvals;
+ vm_oofset_t a_offset;
+ } */ *ap;
{
int code;
+ int i, size, npages, sync;
+ struct uio uio;
+ struct iovec iov;
+ struct buf *bp;
+ vm_offset_t kva;
+ struct vcache *avc=VTOAFS(ap->a_vp);
+
+ if (avc->v.v_object == NULL) {
+ printf("afs_putpages: called with non-merged cache vnode??\n");
+ return VM_PAGER_ERROR;
+ }
+ if (vType(avc) != VREG) {
+ printf("afs_putpages: not VREG");
+ return VM_PAGER_ERROR;
+ }
+ npages=btoc(ap->a_count);
+ for (i=0; i < npages; i++ ) ap->a_rtvals[i]=VM_PAGER_AGAIN;
+ bp = getpbuf(&afs_pbuf_freecnt);
+ kva = (vm_offset_t) bp->b_data;
+ pmap_qenter(kva, ap->a_m, npages);
+ iov.iov_base=(caddr_t)kva;
+ iov.iov_len=ap->a_count;
+ uio.uio_iov=&iov;
+ uio.uio_iovcnt=1;
+ uio.uio_offset=IDX_TO_OFF(ap->a_m[0]->pindex);
+ uio.uio_resid=ap->a_count;
+ uio.uio_segflg=UIO_SYSSPACE;
+ uio.uio_rw=UIO_WRITE;
+ uio.uio_procp=curproc;
+ sync=IO_VMIO;
+ if (ap->a_sync & VM_PAGER_PUT_SYNC)
+ sync|=IO_SYNC;
+ /*if (ap->a_sync & VM_PAGER_PUT_INVAL)
+ sync|=IO_INVAL;*/
+
AFS_GLOCK();
- code = afs_closex(afd);
+ afs_BozonLock(&avc->pvnLock, avc);
+ code=afs_write(avc, &uio, sync, curproc->p_cred->pc_ucred, 0);
+ afs_BozonUnlock(&avc->pvnLock, avc);
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);
-}
+ pmap_qremove(kva, npages);
-mp_afs_abortop(ndp)
- struct nameidata *ndp;
-{
- return(0);
+ relpbuf(bp, &afs_pbuf_freecnt);
+ if (!code) {
+ size = ap->a_count - uio.uio_resid;
+ for (i = 0; i < round_page(size) / PAGE_SIZE; i++) {
+ ap->a_rtvals[i]=VM_PAGER_OK;
+ ap->a_m[i]->dirty=0;
+ }
+ return VM_PAGER_ERROR;
+ }
+ return ap->a_rtvals[0];
}
-
-mp_afs_inactive(avc, acred)
- register struct vcache *avc;
- struct AFS_UCRED *acred;
+int
+afs_vop_ioctl(ap)
+ struct vop_ioctl_args /* {
+ struct vnode *a_vp;
+ int a_command;
+ caddr_t a_data;
+ int a_fflag;
+ struct ucred *a_cred;
+ struct proc *a_p;
+ } */ *ap;
{
+ struct vcache *tvc = VTOAFS(ap->a_vp);
+ struct afs_ioctl data;
+ int error = 0;
+
+ /* in case we ever get in here... */
+
+ AFS_STATCNT(afs_ioctl);
+ if (((ap->a_command >> 8) & 0xff) == 'V') {
+ /* This is a VICEIOCTL call */
AFS_GLOCK();
- afs_InactiveVCache(avc, acred);
+ error = HandleIoctl(tvc, (struct file *)0/*Not used*/,
+ ap->a_command, ap->a_data);
AFS_GUNLOCK();
+ return(error);
+ } else {
+ /* No-op call; just return. */
+ return(ENOTTY);
+ }
}
-
-mp_afs_reclaim(avc)
- struct vcache *avc;
+/* ARGSUSED */
+int
+afs_vop_poll(ap)
+ struct vop_poll_args /* {
+ struct vnode *a_vp;
+ int a_events;
+ struct ucred *a_cred;
+ struct proc *a_p;
+ } */ *ap;
{
- return(0);
+ /*
+ * We should really check to see if I/O is possible.
+ */
+ return (1);
}
-
-mp_afs_print(avc)
- struct vcache *avc;
+/*
+ * Mmap a file
+ *
+ * NB Currently unsupported.
+ */
+/* ARGSUSED */
+int
+afs_vop_mmap(ap)
+ struct vop_mmap_args /* {
+ struct vnode *a_vp;
+ int a_fflags;
+ struct ucred *a_cred;
+ struct proc *a_p;
+ } */ *ap;
{
- return(0);
+ return (EINVAL);
}
-mp_afs_page_read(avc, uio, acred)
- struct vcache *avc;
- struct uio *uio;
- struct ucred *acred;
+int
+afs_vop_fsync(ap)
+ struct vop_fsync_args /* {
+ struct vnode *a_vp;
+ struct ucred *a_cred;
+ int a_waitfor;
+ struct proc *a_p;
+ } */ *ap;
{
+ int wait = ap->a_waitfor == MNT_WAIT;
int error;
- struct vrequest treq;
+ register struct vnode *vp = ap->a_vp;
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);
- }
+ /*vflushbuf(vp, wait);*/
+ if (ap->a_cred)
+ error=afs_fsync(VTOAFS(vp), ap->a_cred);
+ else
+ error=afs_fsync(VTOAFS(vp), &afs_osi_cred);
AFS_GUNLOCK();
- return(error);
+ 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
+afs_vop_remove(ap)
+ struct vop_remove_args /* {
+ struct vnode *a_dvp;
+ struct vnode *a_vp;
+ struct componentname *a_cnp;
+ } */ *ap;
{
- int error;
+ int error = 0;
+ register struct vnode *vp = ap->a_vp;
+ register struct vnode *dvp = ap->a_dvp;
+ GETNAME();
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;
- }
+ error = afs_remove(VTOAFS(dvp), name, cnp->cn_cred);
AFS_GUNLOCK();
- return(error);
+ cache_purge(vp);
+ DROPNAME();
+ return error;
}
-
-int DO_FLUSH=1;
-mp_afs_ubcrdwr(avc, uio, ioflag, cred)
- struct vcache *avc;
- struct uio *uio;
- int ioflag;
- struct ucred *cred;
+int
+afs_vop_link(ap)
+ struct vop_link_args /* {
+ struct vnode *a_vp;
+ struct vnode *a_tdvp;
+ struct componentname *a_cnp;
+ } */ *ap;
{
- 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;
+ int error = 0;
+ register struct vnode *dvp = ap->a_tdvp;
+ register struct vnode *vp = ap->a_vp;
+ struct proc *p;
+
+ GETNAME();
+ p=cnp->cn_proc;
+ if (dvp->v_mount != vp->v_mount) {
+ error = EXDEV;
+ goto out;
}
- 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 (vp->v_type == VDIR) {
+ error = EISDIR;
+ goto out;
}
- 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();
+ if (error = vn_lock(vp, LK_EXCLUSIVE, p)) {
+ goto out;
}
+ AFS_GLOCK();
+ error = afs_link(VTOAFS(vp), VTOAFS(dvp), name, cnp->cn_cred);
+ AFS_GUNLOCK();
+ if (dvp != vp)
+ VOP_UNLOCK(vp,0, p);
+out:
+ DROPNAME();
+ return error;
+}
- 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.
+int
+afs_vop_rename(ap)
+ struct vop_rename_args /* {
+ struct vnode *a_fdvp;
+ struct vnode *a_fvp;
+ struct componentname *a_fcnp;
+ struct vnode *a_tdvp;
+ struct vnode *a_tvp;
+ struct componentname *a_tcnp;
+ } */ *ap;
+{
+ int error = 0;
+ struct componentname *fcnp = ap->a_fcnp;
+ char *fname;
+ struct componentname *tcnp = ap->a_tcnp;
+ char *tname;
+ struct vnode *tvp = ap->a_tvp;
+ register struct vnode *tdvp = ap->a_tdvp;
+ struct vnode *fvp = ap->a_fvp;
+ register struct vnode *fdvp = ap->a_fdvp;
+ struct proc *p=fcnp->cn_proc;
+
+ /*
+ * Check for cross-device rename.
*/
- if (code == EDQUOT || code == ENOSPC) {
- uio->uio_resid = save_resid;
- UpgradeSToWLock(&avc->lock, 410);
- osi_ReleaseVM(avc, cred);
- ConvertWToSLock(&avc->lock);
+ if ((fvp->v_mount != tdvp->v_mount) ||
+ (tvp && (fvp->v_mount != tvp->v_mount))) {
+ error = EXDEV;
+abortit:
+ if (tdvp == tvp)
+ vrele(tdvp);
+ else
+ vput(tdvp);
+ if (tvp)
+ vput(tvp);
+ vrele(fdvp);
+ vrele(fvp);
+ return (error);
}
- ReleaseSharedLock(&avc->lock);
+ /*
+ * if fvp == tvp, we're just removing one name of a pair of
+ * directory entries for the same element. convert call into rename.
+ ( (pinched from FreeBSD 4.4's ufs_rename())
+
+ */
+ if (fvp == tvp) {
+ if (fvp->v_type == VDIR) {
+ error = EINVAL;
+ goto abortit;
+ }
- if (!code && (ioflag & IO_SYNC) && (uio->uio_rw == UIO_WRITE)
- && !AFS_NFSXLATORREQ(cred)) {
- code = afs_fsync(avc, 0, cred, 0);
+ /* Release destination completely. */
+ vput(tdvp);
+ vput(tvp);
+
+ /* Delete source. */
+ vrele(fdvp);
+ vrele(fvp);
+ fcnp->cn_flags &= ~MODMASK;
+ fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
+ if ((fcnp->cn_flags & SAVESTART) == 0)
+ panic("afs_rename: lost from startdir");
+ fcnp->cn_nameiop = DELETE;
+ VREF(fdvp);
+ error=relookup(fdvp, &fvp, fcnp);
+ if (error == 0)
+ vrele(fdvp);
+ if (fvp == NULL) {
+ return (ENOENT);
+ }
+
+ error=VOP_REMOVE(fdvp, fvp, fcnp);
+ if (fdvp == fvp)
+ vrele(fdvp);
+ else
+ vput(fdvp);
+ vput(fvp);
+ return (error);
}
-out:
- code = afs_CheckCode(code, &treq, 36);
- AFS_GUNLOCK();
- return code;
-}
+ if (error = vn_lock(fvp, LK_EXCLUSIVE, p))
+ goto abortit;
+ MALLOC(fname, char *, fcnp->cn_namelen+1, M_TEMP, M_WAITOK);
+ memcpy(fname, fcnp->cn_nameptr, fcnp->cn_namelen);
+ fname[fcnp->cn_namelen] = '\0';
+ MALLOC(tname, char *, tcnp->cn_namelen+1, M_TEMP, M_WAITOK);
+ memcpy(tname, tcnp->cn_nameptr, tcnp->cn_namelen);
+ tname[tcnp->cn_namelen] = '\0';
-/*
- * 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;
+ /* XXX use "from" or "to" creds? NFS uses "to" creds */
+ error = afs_rename(VTOAFS(fdvp), fname, VTOAFS(tdvp), tname, tcnp->cn_cred);
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;
-}
+ FREE(fname, M_TEMP);
+ FREE(tname, M_TEMP);
+ if (tdvp == tvp)
+ vrele(tdvp);
+ else
+ vput(tdvp);
+ if (tvp)
+ vput(tvp);
+ vrele(fdvp);
+ vput(fvp);
+ return error;
+}
-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;
+int
+afs_vop_mkdir(ap)
+ struct vop_mkdir_args /* {
+ struct vnode *a_dvp;
+ struct vnode **a_vpp;
+ struct componentname *a_cnp;
+ struct vattr *a_vap;
+ } */ *ap;
{
- 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 */
-
+ register struct vnode *dvp = ap->a_dvp;
+ register struct vattr *vap = ap->a_vap;
+ int error = 0;
+ struct vcache *vcp;
+ struct proc *p;
+
+ GETNAME();
+ p=cnp->cn_proc;
+#ifdef DIAGNOSTIC
+ if ((cnp->cn_flags & HASBUF) == 0)
+ panic("afs_vop_mkdir: no name");
+#endif
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 */
+ error = afs_mkdir(VTOAFS(dvp), name, vap, &vcp, cnp->cn_cred);
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;
- }
- }
+ if (error) {
+ vput(dvp);
+ DROPNAME();
+ return(error);
}
-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;
+ if (vcp) {
+ *ap->a_vpp = AFSTOV(vcp);
+ vn_lock(AFSTOV(vcp), LK_EXCLUSIVE|LK_RETRY, p);
+ } else
+ *ap->a_vpp = 0;
+ DROPNAME();
+ return error;
}
-
-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;
+int
+afs_vop_rmdir(ap)
+ struct vop_rmdir_args /* {
+ struct vnode *a_dvp;
+ struct vnode *a_vp;
+ struct componentname *a_cnp;
+ } */ *ap;
{
- register afs_int32 code=0;
- struct vcache *avc = (struct vcache *)vop->vu_vp;
- struct vnode *vp = (struct vnode *)avc;
- int i;
+ int error = 0;
+ register struct vnode *vp = ap->a_vp;
+ register struct vnode *dvp = ap->a_dvp;
+ GETNAME();
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);
+ error = afs_rmdir(VTOAFS(dvp), name, cnp->cn_cred);
AFS_GUNLOCK();
- return code;
+ DROPNAME();
+ return error;
}
-
-int mp_afs_swap(avc, swapop, argp)
- struct vcache *avc;
- vp_swap_op_t swapop;
- vm_offset_t argp;
+int
+afs_vop_symlink(ap)
+ struct vop_symlink_args /* {
+ struct vnode *a_dvp;
+ struct vnode **a_vpp;
+ struct componentname *a_cnp;
+ struct vattr *a_vap;
+ char *a_target;
+ } */ *ap;
{
- return EIO;
-}
+ register struct vnode *dvp = ap->a_dvp;
+ int error = 0;
+ /* NFS ignores a_vpp; so do we. */
-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;
+ GETNAME();
+ AFS_GLOCK();
+ error = afs_symlink(VTOAFS(dvp), name, ap->a_vap, ap->a_target,
+ cnp->cn_cred);
+ AFS_GUNLOCK();
+ DROPNAME();
+ return error;
}
-/* 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
+afs_vop_readdir(ap)
+ struct vop_readdir_args /* {
+ struct vnode *a_vp;
+ struct uio *a_uio;
+ struct ucred *a_cred;
+ int *a_eofflag;
+ u_long *a_cookies;
+ int ncookies;
+ } */ *ap;
{
- 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);
+ int error;
+ off_t off;
+/* printf("readdir %x cookies %x ncookies %d\n", ap->a_vp, ap->a_cookies,
+ ap->a_ncookies); */
+ off=ap->a_uio->uio_offset;
+ AFS_GLOCK();
+ error= afs_readdir(VTOAFS(ap->a_vp), ap->a_uio, ap->a_cred,
+ ap->a_eofflag);
+ AFS_GUNLOCK();
+ if (!error && ap->a_ncookies != NULL) {
+ struct uio *uio = ap->a_uio;
+ const struct dirent *dp, *dp_start, *dp_end;
+ int ncookies;
+ u_long *cookies, *cookiep;
+
+ if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1)
+ panic("afs_readdir: burned cookies");
+ dp = (const struct dirent *)
+ ((const char *)uio->uio_iov->iov_base - (uio->uio_offset - off));
+
+ dp_end = (const struct dirent *) uio->uio_iov->iov_base;
+ for (dp_start = dp, ncookies = 0;
+ dp < dp_end;
+ dp = (const struct dirent *)((const char *) dp + dp->d_reclen))
+ ncookies++;
+
+ MALLOC(cookies, u_long *, ncookies * sizeof(u_long),
+ M_TEMP, M_WAITOK);
+ for (dp = dp_start, cookiep = cookies;
+ dp < dp_end;
+ dp = (const struct dirent *)((const char *) dp + dp->d_reclen)) {
+ off += dp->d_reclen;
+ *cookiep++ = off;
}
+ *ap->a_cookies = cookies;
+ *ap->a_ncookies = ncookies;
+ }
- 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;
+ return error;
}
-
-mp_afs_brelse(vp, bp)
-struct vnode *vp;
-struct buf *bp;
+int
+afs_vop_readlink(ap)
+ struct vop_readlink_args /* {
+ struct vnode *a_vp;
+ struct uio *a_uio;
+ struct ucred *a_cred;
+ } */ *ap;
{
+ int error;
+/* printf("readlink %x\n", ap->a_vp);*/
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;
- }
+ error= afs_readlink(VTOAFS(ap->a_vp), ap->a_uio, ap->a_cred);
AFS_GUNLOCK();
+ return error;
}
+extern int prtactive;
-mp_afs_bmap(avc, abn, anvp, anbn)
- register struct vcache *avc;
- afs_int32 abn, *anbn;
- struct vcache **anvp;
+int
+afs_vop_inactive(ap)
+ struct vop_inactive_args /* {
+ struct vnode *a_vp;
+ struct proc *a_p;
+ } */ *ap;
{
+ register struct vnode *vp = ap->a_vp;
+
+ if (prtactive && vp->v_usecount != 0)
+ vprint("afs_vop_inactive(): pushing active", vp);
+
AFS_GLOCK();
- AFS_STATCNT(afs_bmap);
- if (anvp)
- *anvp = avc;
- if (anbn)
- *anbn = abn * (8192 / DEV_BSIZE); /* in 512 byte units */
+ afs_InactiveVCache(VTOAFS(vp), 0); /* decrs ref counts */
AFS_GUNLOCK();
+ VOP_UNLOCK(vp, 0, ap->a_p);
return 0;
}
-
-/* real strategy */
-mp_afs_strategy (abp)
- register struct buf *abp;
+int
+afs_vop_reclaim(ap)
+ struct vop_reclaim_args /* {
+ struct vnode *a_vp;
+ } */ *ap;
{
- register afs_int32 code;
+ int error;
+ int sl;
+ register struct vnode *vp = ap->a_vp;
+
+ cache_purge(vp); /* just in case... */
+#if 0
AFS_GLOCK();
- AFS_STATCNT(afs_strategy);
- code = afs_osi_MapStrategy(afs_ustrategy, abp);
+ error = afs_FlushVCache(VTOAFS(vp), &sl); /* tosses our stuff from vnode */
AFS_GUNLOCK();
- return code;
+ ubc_unlink(vp);
+ if (!error && vp->v_data)
+ panic("afs_reclaim: vnode not cleaned");
+ return error;
+#else
+ if (vp->v_usecount == 2) {
+ vprint("reclaim count==2", vp);
+ } else if (vp->v_usecount == 1) {
+ vprint("reclaim count==1", vp);
+ } else
+ vprint("reclaim bad count", vp);
+
+ return 0;
+#endif
}
-
-mp_afs_refer(vm_ubc_object_t vop)
+int
+afs_vop_lock(ap)
+ struct vop_lock_args /* {
+ struct vnode *a_vp;
+ } */ *ap;
{
- VREF(vop->vu_vp);
-}
+ register struct vnode *vp = ap->a_vp;
+ register struct vcache *avc = VTOAFS(vp);
+ if (vp->v_tag == VT_NON)
+ return (ENOENT);
+ return (lockmgr(&avc->rwlock, ap->a_flags, &vp->v_interlock,
+ ap->a_p));
+}
-mp_afs_release(vm_ubc_object_t vop)
+int
+afs_vop_unlock(ap)
+ struct vop_unlock_args /* {
+ struct vnode *a_vp;
+ } */ *ap;
{
- vrele(vop->vu_vp);
-}
+ struct vnode *vp = ap->a_vp;
+ struct vcache *avc = VTOAFS(vp);
+ return (lockmgr(&avc->rwlock, ap->a_flags | LK_RELEASE,
+ &vp->v_interlock, ap->a_p));
+}
-mp_afs_write_check(vm_ubc_object_t vop, vm_page_t pp)
+int
+afs_vop_bmap(ap)
+ struct vop_bmap_args /* {
+ struct vnode *a_vp;
+ daddr_t a_bn;
+ struct vnode **a_vpp;
+ daddr_t *a_bnp;
+ int *a_runp;
+ int *a_runb;
+ } */ *ap;
{
- return TRUE;
+ struct vcache *vcp;
+ int error;
+ if (ap->a_bnp) {
+ *ap->a_bnp = ap->a_bn * (PAGE_SIZE / DEV_BSIZE);
+ }
+ if (ap->a_vpp) {
+ *ap->a_vpp = ap->a_vp;
+ }
+ if (ap->a_runp != NULL)
+ *ap->a_runp = 0;
+ if (ap->a_runb != NULL)
+ *ap->a_runb = 0;
+
+ return 0;
+}
+int
+afs_vop_strategy(ap)
+ struct vop_strategy_args /* {
+ struct buf *a_bp;
+ } */ *ap;
+{
+ int error;
+ AFS_GLOCK();
+ error= afs_ustrategy(ap->a_bp);
+ AFS_GUNLOCK();
+ return error;
+}
+int
+afs_vop_print(ap)
+ struct vop_print_args /* {
+ struct vnode *a_vp;
+ } */ *ap;
+{
+ register struct vnode *vp = ap->a_vp;
+ register struct vcache *vc = VTOAFS(ap->a_vp);
+ int s = vc->states;
+ printf("tag %d, fid: %ld.%x.%x.%x, opens %d, writers %d", vp->v_tag, vc->fid.Cell,
+ vc->fid.Fid.Volume, vc->fid.Fid.Vnode, vc->fid.Fid.Unique, vc->opens,
+ vc->execsOrWriters);
+ printf("\n states%s%s%s%s%s", (s&CStatd) ? " statd" : "", (s&CRO) ? " readonly" : "",(s&CDirty) ? " dirty" : "",(s&CMAPPED) ? " mapped" : "", (s&CVFlushed) ? " flush in progress" : "");
+ printf("\n");
+ return 0;
}
-
-
-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 */
+int
+afs_vop_islocked(ap)
+ struct vop_islocked_args /* {
+ struct vnode *a_vp;
+ } */ *ap;
+{
+ struct vcache *vc = VTOAFS(ap->a_vp);
+ return lockstatus(&vc->rwlock, ap->a_p);
+}
/*
- * 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.
+ * Advisory record locking support (fcntl() POSIX style)
*/
-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 */
+int
+afs_vop_advlock(ap)
+ struct vop_advlock_args /* {
+ struct vnode *a_vp;
+ caddr_t a_id;
+ int a_op;
+ struct flock *a_fl;
+ int a_flags;
+ } */ *ap;
{
- /* 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);
+ struct proc *p=curproc;
+ struct ucred cr;
+ cr=*p->p_cred->pc_ucred;
+ AFS_GLOCK();
+ error= afs_lockctl(VTOAFS(ap->a_vp), ap->a_fl, ap->a_op, &cr,
+ (int) ap->a_id);
+ AFS_GUNLOCK();
+ return error;
}
-/*
- * 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.
rc = VCALL(vp, VOFFSET(vop_poll), &a);
return (rc);
}
+struct vop_kqfilter_args {
+ struct vnodeop_desc *a_desc;
+ struct vnode *a_vp;
+ struct knote *a_kn;
+};
+extern struct vnodeop_desc vop_kqfilter_desc;
+static __inline int VOP_KQFILTER __P((
+ struct vnode *vp,
+ struct knote *kn));
+static __inline int VOP_KQFILTER(vp, kn)
+ struct vnode *vp;
+ struct knote *kn;
+{
+ struct vop_kqfilter_args a;
+ int rc;
+ a.a_desc = VDESC(vop_kqfilter);
+ a.a_vp = vp;
+ a.a_kn = kn;
+ rc = VCALL(vp, VOFFSET(vop_kqfilter), &a);
+ return (rc);
+}
struct vop_revoke_args {
struct vnodeop_desc *a_desc;
struct vnode *a_vp;
rc = VCALL(vp, VOFFSET(vop_setextattr), &a);
return (rc);
}
+struct vop_createvobject_args {
+ struct vnodeop_desc *a_desc;
+ struct vnode *a_vp;
+ struct ucred *a_cred;
+ struct proc *a_p;
+};
+extern struct vnodeop_desc vop_createvobject_desc;
+static __inline int VOP_CREATEVOBJECT __P((
+ struct vnode *vp,
+ struct ucred *cred,
+ struct proc *p));
+static __inline int VOP_CREATEVOBJECT(vp, cred, p)
+ struct vnode *vp;
+ struct ucred *cred;
+ struct proc *p;
+{
+ struct vop_createvobject_args a;
+ int rc;
+ a.a_desc = VDESC(vop_createvobject);
+ a.a_vp = vp;
+ a.a_cred = cred;
+ a.a_p = p;
+ rc = VCALL(vp, VOFFSET(vop_createvobject), &a);
+ return (rc);
+}
+struct vop_destroyvobject_args {
+ struct vnodeop_desc *a_desc;
+ struct vnode *a_vp;
+};
+extern struct vnodeop_desc vop_destroyvobject_desc;
+static __inline int VOP_DESTROYVOBJECT __P((
+ struct vnode *vp));
+static __inline int VOP_DESTROYVOBJECT(vp)
+ struct vnode *vp;
+{
+ struct vop_destroyvobject_args a;
+ int rc;
+ a.a_desc = VDESC(vop_destroyvobject);
+ a.a_vp = vp;
+ rc = VCALL(vp, VOFFSET(vop_destroyvobject), &a);
+ return (rc);
+}
+struct vop_getvobject_args {
+ struct vnodeop_desc *a_desc;
+ struct vnode *a_vp;
+ struct vm_object **a_objpp;
+};
+extern struct vnodeop_desc vop_getvobject_desc;
+static __inline int VOP_GETVOBJECT __P((
+ struct vnode *vp,
+ struct vm_object **objpp));
+static __inline int VOP_GETVOBJECT(vp, objpp)
+ struct vnode *vp;
+ struct vm_object **objpp;
+{
+ struct vop_getvobject_args a;
+ int rc;
+ a.a_desc = VDESC(vop_getvobject);
+ a.a_vp = vp;
+ a.a_objpp = objpp;
+ rc = VCALL(vp, VOFFSET(vop_getvobject), &a);
+ return (rc);
+}
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/SOLARIS/osi_file.c,v 1.1.1.7 2001/10/14 17:59:09 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/SOLARIS/osi_file.c,v 1.1.1.8 2002/09/26 18:58:18 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
osi_Panic("afs_osi_Write called with null param");
if (offset != -1) afile->offset = offset;
AFS_GUNLOCK();
-#ifdef AFS_SUN59_ENV
- code = gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize, afile->offset,
- AFS_UIOSYS, 0, curproc->p_fsz_ctl.rlim_cur, &afs_osi_cred, &resid);
-#else
- code = gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize, afile->offset,
- AFS_UIOSYS, 0, (u.u_rlimit[RLIMIT_FSIZE].rlim_cur), &afs_osi_cred, &resid);
-#endif
+ code = gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize,
+ afile->offset, AFS_UIOSYS, 0, RLIM64_INFINITY,
+ &afs_osi_cred, &resid);
AFS_GLOCK();
if (code == 0) {
code = asize - resid;
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_attrs.c,v 1.1.1.10 2002/08/02 04:29:00 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_attrs.c,v 1.1.1.11 2002/09/26 18:58:21 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
* 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) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+ /* nfs on these systems puts an 0 in nsec and stores the nfs usec (aka
+ dataversion) in va_gen */
+
+ attrs->va_atime.tv_nsec = attrs->va_mtime.tv_nsec =
+ attrs->va_ctime.tv_nsec =0;
+ attrs->va_blocksize = PAGESIZE; /* XXX Was 8192 XXX */
+ attrs->va_gen = hgetlo(avc->m.DataVersion);
+ attrs->va_flags = 0;
+#else
+#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_AIX41_ENV)
attrs->va_atime.tv_nsec = attrs->va_mtime.tv_nsec =
attrs->va_ctime.tv_nsec =
(hgetlo(avc->m.DataVersion) & 0x7ffff) * 1000;
(hgetlo(avc->m.DataVersion) & 0x7ffff);
attrs->va_blocksize = PAGESIZE; /* XXX Was 8192 XXX */
#endif
+#endif
#ifdef AFS_DEC_ENV
/* Have to use real device #s in Ultrix, since that's how FS type is
* encoded. If rdev doesn't match Ultrix equivalent of statfs's rdev, then
* Below return 0 (and not 1) blocks if the file is zero length. This conforms
* better with the other filesystems that do return 0.
*/
-#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_OSF_ENV)
#ifdef va_size_rsv
attrs->va_size_rsv = 0;
#endif
/* XXX do this */
/* attrs->va_gen = avc->m.DataVersion;*/
attrs->va_flags = 0;
-#endif /* AFS_OSF_ENV || AFS_DARWIN_ENV */
+#endif /* AFS_OSF_ENV */
#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
#if !defined(AFS_HPUX_ENV)
return code;
}
#endif
+#if defined(AFS_DARWIN_ENV)
+ if (avc->states & CUBCinit) {
+ code = afs_CopyOutAttrs(avc, attrs);
+ return code;
+ }
+#endif
#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) || defined(AFS_SUN5_ENV)
afs_BozonLock(&avc->pvnLock, avc);
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_flock.c,v 1.1.1.10 2002/08/02 04:29:01 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_flock.c,v 1.1.1.11 2002/09/26 18:58:22 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
static int GetFlockCount(struct vcache *avc, struct vrequest *areq);
void lockIdSet(flock, slp, clid)
- int clid; /* non-zero on SGI, OSF, SunOS */
+ int clid; /* non-zero on SGI, OSF, SunOS, Darwin, xBSD *//* XXX ptr type */
struct SimpleLocks *slp;
struct AFS_FLOCK *flock;
{
}
#endif
if ((flock1->l_pid == alp->pid) ||
-#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV)
(!onlymine && (flock1->l_pid == getppid()))
#else
-#if defined(AFS_SGI65_ENV)
+#if defined(AFS_SGI65_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+ /* XXX check this. used to be *only* irix for some reason. */
(!onlymine && (flock1->l_pid == clid))
#else
(!onlymine && (flock1->l_pid == procp->p_ppid))
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) {
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_read.c,v 1.1.1.6 2002/08/02 04:29:03 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_read.c,v 1.1.1.7 2002/09/26 18:58:24 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
code = VOP_READ(tfile->vnode, auio, 0, &afs_osi_cred);
VOP_UNLOCK(tfile->vnode, 0, current_proc());
AFS_GLOCK();
+#else
+#if defined(AFS_FBSD_ENV)
+ AFS_GUNLOCK();
+ VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curproc);
+ code = VOP_READ(tfile->vnode, auio, 0, &afs_osi_cred);
+ VOP_UNLOCK(tfile->vnode, 0, curproc);
+ AFS_GLOCK();
#else
code = VOP_RDWR(tfile->vnode, auio, UIO_READ, 0, &afs_osi_cred);
#endif
#endif
#endif
#endif
+#endif
#endif
auio->afsio_offset += avc->quick.minLoc;
osi_UFSClose(tfile);
code = VOP_READ(tfile->vnode, &tuio, 0, &afs_osi_cred);
VOP_UNLOCK(tfile->vnode, 0, current_proc());
AFS_GLOCK();
+#else
+#if defined(AFS_FBSD_ENV)
+ AFS_GUNLOCK();
+ VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curproc);
+ code = VOP_READ(tfile->vnode, &tuio, 0, &afs_osi_cred);
+ VOP_UNLOCK(tfile->vnode, 0, curproc);
+ AFS_GLOCK();
#else
- code = VOP_RDWR(tfile->vnode, &tuio, UIO_READ, 0, &afs_osi_cred);
+ code = VOP_RDWR(tfile->vnode, &tuio, UIO_READ, 0, &afs_osi_cred);
+#endif
#endif
#endif
#endif
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_strategy.c,v 1.1.1.8 2002/05/10 23:44:25 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_strategy.c,v 1.1.1.9 2002/09/26 18:58:25 hartmans Exp $");
#if !defined(AFS_HPUX_ENV) && !defined(AFS_SGI_ENV) && !defined(AFS_LINUX20_ENV)
#endif
}
#if !defined(AFS_AIX32_ENV) && !defined(AFS_SUN5_ENV)
-#ifdef AFS_DUX40_ENV
+#if defined(AFS_DUX40_ENV) || defined(AFS_FBSD_ENV)
if (code) {
abp->b_error = code;
abp->b_flags |= B_ERROR;
}
biodone(abp);
+#if defined(AFS_DUX40_ENV)
if (code && !(abp->b_flags & B_READ)) {
/* prevent ubc from retrying writes */
AFS_GUNLOCK();
PAGE_SIZE, B_INVAL);
AFS_GLOCK();
}
-#else /* AFS_DUX40_ENV */
+#endif
+#else /* AFS_DUX40_ENV || AFS_FBSD_ENV */
iodone(abp);
-#endif /* AFS_DUX40_ENV */
+#endif /* AFS_DUX40_ENV || AFS_FBSD_ENV */
#endif
#ifdef AFS_AIX32_ENV
crfree(credp);
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_write.c,v 1.1.1.11 2002/08/02 04:29:04 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/VNOPS/afs_vnop_write.c,v 1.1.1.12 2002/09/26 18:58:25 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
code = osi_file_uio_rdwr(tfile, &tuio, UIO_WRITE);
AFS_GLOCK();
#else
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV)
AFS_GUNLOCK();
VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
code = VOP_WRITE(tfile->vnode, &tuio, 0, &afs_osi_cred);
VOP_UNLOCK(tfile->vnode, 0, current_proc());
AFS_GLOCK();
+#else
+#if defined(AFS_FBSD_ENV)
+ AFS_GUNLOCK();
+ VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curproc);
+ code = VOP_WRITE(tfile->vnode, &tuio, 0, &afs_osi_cred);
+ VOP_UNLOCK(tfile->vnode, 0, curproc);
+ AFS_GLOCK();
#else
code = VOP_RDWR(tfile->vnode, &tuio, UIO_WRITE, 0, &afs_osi_cred);
-#endif /* AFS_DARWIN_ENV || AFS_FBSD_ENV */
+#endif /* AFS_FBSD_ENV */
+#endif /* AFS_DARWIN_ENV */
#endif /* AFS_LINUX20_ENV */
#endif /* AFS_HPUX100_ENV */
#endif /* AFS_OSF_ENV */
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_analyze.c,v 1.1.1.8 2001/10/14 17:58:52 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_analyze.c,v 1.1.1.9 2002/09/26 18:57:48 hartmans Exp $");
#include "../afs/stds.h"
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#ifdef AFS_SGI62_ENV
#include "../h/hashing.h"
#endif
-#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV)
+#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_DARWIN60_ENV)
#include <netinet/in_var.h>
#endif
#endif /* !UKERNEL */
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_buffer.c,v 1.1.1.6 2001/10/14 17:58:52 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_buffer.c,v 1.1.1.7 2002/09/26 18:57:48 hartmans Exp $");
#include "../afs/sysincludes.h"
#if !defined(UKERNEL)
#ifdef AFS_AIX_ENV
extern struct buf *geteblk();
#endif
+#ifdef AFS_FBSD_ENV
+#define timecounter afs_timecounter
+#endif
/* The locks for individual buffer entries are now sometimes obtained while holding the
* afs_bufferLock. Thus we now have a locking hierarchy: afs_bufferLock -> Buffers[].lock.
*/
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_cell.c,v 1.1.1.10 2002/08/02 04:28:38 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_cell.c,v 1.1.1.11 2002/09/26 18:57:50 hartmans Exp $");
#include "../afs/stds.h"
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#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_DARWIN60_ENV)
#include <netinet/in_var.h>
#endif /* ! ASF_HPUX110_ENV */
#endif /* !defined(UKERNEL) */
tc->vlport = (vlport ? vlport : AFS_VLPORT);
afs_stats_cmperf.numCellsVisible++;
newc++;
- if (!aflags & CAlias) {
+ if (!(aflags & CAlias)) {
tc->realcellIndex = afs_realcellindex++;
} else {
tc->realcellIndex = -1;
tc->timeout = timeout;
/* Allow converting an alias into a real cell */
- if (!(aflags & CAlias)) {
+ if ((!(aflags & CAlias)) && (tc->states & CAlias)) {
tc->states &= ~CAlias;
tc->realcellIndex = afs_realcellindex++;
}
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_conn.c,v 1.1.1.7 2001/09/11 14:24:38 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_conn.c,v 1.1.1.8 2002/09/26 18:57:50 hartmans Exp $");
#include "../afs/stds.h"
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#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_DARWIN60_ENV)
#include <netinet/in_var.h>
#endif /* ! AFS_HPUX110_ENV */
#endif /* !defined(UKERNEL) */
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_init.c,v 1.1.1.7 2001/09/11 14:24:40 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_init.c,v 1.1.1.8 2002/09/26 18:57:51 hartmans Exp $");
#include "../afs/stds.h"
#include "../afs/sysincludes.h" /* Standard vendor system headers */
/* Exported variables */
struct osi_dev cacheDev; /*Cache device*/
afs_int32 cacheInfoModTime; /*Last time cache info modified*/
-#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)
struct mount *afs_cacheVfsp=0;
#elif defined(AFS_LINUX20_ENV)
struct super_block *afs_cacheSBp = 0;
TO_KERNEL_SPACE();
}
#else
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV)
if (!VFS_STATFS(filevp->v_mount, &st, current_proc()))
+#else
+#if defined(AFS_FBSD_ENV)
+ if (!VFS_STATFS(filevp->v_mount, &st, curproc))
#else
if (!VFS_STATFS(filevp->v_vfsp, &st))
-#endif /* AFS_DARWIN_ENV || AFS_FBSD_ENV */
+#endif /* AFS_FBSD_ENV */
+#endif /* AFS_DARWIN_ENV */
#endif /* AFS_LINUX20_ENV */
#endif /* AIX41 */
#endif /* OSF */
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_mariner.c,v 1.1.1.4 2001/07/14 22:19:21 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_mariner.c,v 1.1.1.5 2002/09/26 18:57:52 hartmans Exp $");
#include "../afs/sysincludes.h" /*Standard vendor system headers*/
#include "../afs/afsincludes.h" /*AFS-based standard headers*/
taddr.sin_family = AF_INET;
taddr.sin_addr.s_addr = afs_marinerHost;
taddr.sin_port = htons(2106);
-#ifdef AFS_OSF_ENV
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
taddr.sin_len = sizeof(taddr);
-#endif /* AFS_OSF_ENV */
+#endif /* STRUCT_SOCKADDR_HAS_SA_LEN */
tp = tp1 = (char *) osi_AllocSmallSpace(AFS_SMALLOCSIZ);
strcpy(tp, "fetch$Fetching ");
tp += 15; /* change it if string changes */
taddr.sin_family = AF_INET;
taddr.sin_addr.s_addr = afs_marinerHost;
taddr.sin_port = htons(2106);
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ taddr.sin_len = sizeof(taddr);
+#endif /* STRUCT_SOCKADDR_HAS_SA_LEN */
tp = buf = (char *) osi_AllocSmallSpace(AFS_SMALLOCSIZ);
strcpy(tp, astring);
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_nfsclnt.c,v 1.1.1.5 2001/09/11 14:24:41 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_nfsclnt.c,v 1.1.1.6 2002/09/26 18:57:52 hartmans Exp $");
#if !defined(AFS_NONFSTRANS) || defined(AFS_AIX_IAUTH_ENV)
#ifndef AFS_DEC_ENV
shutdown_nfsclnt() {
+#if 0
extern int afs_allnfsreqs, afs_nfscalls;
+#endif
#if defined(AFS_SGIMP_ENV)
osi_Assert(ISAFS_GLOCK());
#endif
afs_nfsclient_GC(afs_nfsexporter, -1);
init_nfsexporter = 0;
+#if 0
/* The following are for the nfs/afs server */
afs_allnfsreqs = afs_nfscalls = 0;
+#endif
}
#endif /* AFS_DEC_ENV */
#endif /* AFS_NONFSTRANS */
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_osi.c,v 1.1.1.11 2002/08/02 04:28:40 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_osi.c,v 1.1.1.12 2002/09/26 18:57:53 hartmans Exp $");
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
afs_global_owner = (thread_t)0;
#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;
+ afs_global_owner = 0;
#elif defined(AFS_AIX41_ENV)
lock_alloc((void*)&afs_global_lock, LOCK_ALLOC_PIN, 1, 1);
simple_lock_init((void *)&afs_global_lock);
#if AFS_HPUX101_ENV
set_system_proc(u.u_procp);
#endif
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV)
/* maybe call init_process instead? */
current_proc()->p_flag |= P_SYSTEM;
#endif
+#if defined(AFS_FBSD_ENV)
+ curproc->p_flag |= P_SYSTEM;
+#endif
#if defined(AFS_SGI_ENV)
vrelvm();
#endif /* AFS_SGI_ENV */
stime(&sta);
AFS_GLOCK();
#else
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_FBSD_ENV)
+ /* does not impliment security features of kern_time.c:settime() */
+ struct timespec ts;
+ struct timeval tv,delta;
+ extern void (*lease_updatetime)();
+ int s;
+ AFS_GUNLOCK();
+ s=splclock();
+ microtime(&tv);
+ delta=*atv;
+ timevalsub(&delta, &tv);
+ ts.tv_sec=atv->tv_sec;
+ ts.tv_nsec=atv->tv_usec * 1000;
+ set_timecounter(&ts);
+ (void) splsoftclock();
+ lease_updatetime(delta.tv_sec);
+ splx(s);
+ resettodr();
+ AFS_GLOCK();
+#else
+#if defined(AFS_DARWIN_ENV)
AFS_GUNLOCK();
setthetime(atv);
AFS_GLOCK();
#ifdef AFS_AUX_ENV
logtchg(atv->tv_sec);
#endif
-#endif /* AFS_DARWIN_ENV || AFS_FBSD_ENV */
+#endif /* AFS_DARWIN_ENV */
+#endif /* AFS_FBSD_ENV */
#endif /* AFS_SGI_ENV */
#endif /* AFS_SUN55_ENV */
#endif /* AFS_SUN5_ENV */
void afs_osi_TraverseProcTable()
{
struct task_struct *p;
+
+#ifdef EXPORTED_TASKLIST_LOCK
+ read_lock(&tasklist_lock);
+#endif
for_each_task(p) if (p->pid) {
if (p->state & TASK_ZOMBIE)
continue;
-#if 0
- if (p->flags & )
- continue;
-#endif
afs_GCPAGs_perproc_func(p);
}
+#ifdef EXPORTED_TASKLIST_LOCK
+ read_unlock(&tasklist_lock);
+#endif
}
#endif
(pr->state == TASK_INTERRUPTIBLE) ||
(pr->state == TASK_UNINTERRUPTIBLE) ||
(pr->state == TASK_STOPPED)) {
- read_lock(&tasklist_lock);
- cr.cr_ref=1;
- cr.cr_uid=pr->uid;
- cr.cr_ngroups=pr->ngroups;
- memcpy(cr.cr_groups, pr->groups, NGROUPS * sizeof(gid_t));
- read_unlock(&tasklist_lock);
- rv = &cr;
+ cr.cr_ref=1;
+ cr.cr_uid=pr->uid;
+ cr.cr_ngroups=pr->ngroups;
+ memcpy(cr.cr_groups, pr->groups, NGROUPS * sizeof(gid_t));
+ rv = &cr;
}
return rv;
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_server.c,v 1.1.1.12 2002/05/10 23:43:22 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_server.c,v 1.1.1.13 2002/09/26 18:57:56 hartmans Exp $");
#include "../afs/stds.h"
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#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_DARWIN60_ENV)
#include <netinet/in_var.h>
#endif /* AFS_HPUX110_ENV */
+#ifdef AFS_DARWIN60_ENV
+#include <net/if_var.h>
+#endif
#endif /* !defined(UKERNEL) */
#include "../afs/afsincludes.h" /* Afs-based standard headers */
}
}
#else /* AFS_USERSPACE_IP_ADDR */
-#if (! defined(AFS_SUN5_ENV)) && defined(USEIFADDR)
+#if (! defined(AFS_SUN5_ENV)) && !defined(AFS_DARWIN60_ENV) && defined(USEIFADDR)
void
afsi_SetServerIPRank(sa, ifa)
struct srvAddr *sa;
#endif /* IFF_POINTTOPOINT */
}
#endif /*(!defined(AFS_SUN5_ENV)) && defined(USEIFADDR)*/
+#if defined(AFS_DARWIN60_ENV) && defined(USEIFADDR)
+#ifndef afs_min
+#define afs_min(A,B) ((A)<(B)) ? (A) : (B)
+#endif
+void
+afsi_SetServerIPRank(sa, ifa)
+ struct srvAddr *sa;
+ struct ifaddr *ifa;
+{
+ struct sockaddr_in *sin;
+ int t;
+
+ afs_uint32 subnetmask, myAddr, myNet, myDstaddr, mySubnet, netMask;
+ afs_uint32 serverAddr ;
+
+ if (ifa->ifa_addr->sa_family != AF_INET)
+ return;
+ sin=(struct sockaddr_in *)ifa->ifa_addr;
+ myAddr = ntohl(sin->sin_addr.s_addr); /* one of my IP addr in host order */
+ serverAddr = ntohl(sa->sa_ip); /* server's IP addr in host order */
+ sin=(struct sockaddr_in *)ifa->ifa_netmask;
+ subnetmask = ntohl(sin->sin_addr.s_addr);/* subnet mask in host order */
+ sin=(struct sockaddr_in *)ifa->ifa_dstaddr;
+ if (sin)
+ myDstaddr=sin->sin_addr.s_addr;
+
+ if ( IN_CLASSA(myAddr) ) netMask = IN_CLASSA_NET;
+ else if ( IN_CLASSB(myAddr) ) netMask = IN_CLASSB_NET;
+ else if ( IN_CLASSC(myAddr) ) netMask = IN_CLASSC_NET;
+ else netMask = 0;
+
+ myNet = myAddr & netMask;
+ mySubnet = myAddr & subnetmask;
+
+ if ( (serverAddr & netMask ) == myNet ) {
+ if ( (serverAddr & subnetmask ) == mySubnet) {
+ if ( serverAddr == myAddr ) { /* same machine */
+ sa->sa_iprank = afs_min(sa->sa_iprank, TOPR);
+ } else { /* same subnet */
+ sa->sa_iprank = afs_min(sa->sa_iprank, HI + ifa->ifa_metric);
+ }
+ } else { /* same net */
+ sa->sa_iprank = afs_min(sa->sa_iprank, MED + ifa->ifa_metric);
+ }
+ }
+#ifdef IFF_POINTTOPOINT
+ /* check for case #4 -- point-to-point link */
+ if ((ifa->ia_ifp->if_flags & IFF_POINTOPOINT) &&
+ (myDstaddr == serverAddr))) {
+ if (ifa->ia_ifp->if_metric >= (MAXDEFRANK - MED)/PPWEIGHT)
+ t = MAXDEFRANK;
+ else
+ t = MED + (PPWEIGHT << ifa->->ifa_metric);
+ if (sa->sa_iprank > t)
+ sa->sa_iprank = t;
+ }
+#endif /* IFF_POINTTOPOINT */
+}
+#endif /*(!defined(AFS_SUN5_ENV)) && defined(USEIFADDR)*/
#endif /* else AFS_USERSPACE_IP_ADDR */
#ifdef AFS_SGI62_ENV
#ifdef AFS_SGI62_ENV
(void) hash_enum(&hashinfo_inaddr, afsi_enum_set_rank, HTF_INET, NULL,
(caddr_t)sa, NULL);
+#elif defined(AFS_DARWIN60_ENV)
+ {
+ struct ifnet *ifn;
+ struct ifaddr *ifa;
+ TAILQ_FOREACH(ifn , &ifnet, if_link) {
+ TAILQ_FOREACH(ifa , &ifn->if_addrhead, ifa_link) {
+ afsi_SetServerIPRank(sa, ifa);
+ }
+ }
+ }
#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
{
struct in_ifaddr *ifa;
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_user.c,v 1.1.1.7 2001/09/11 14:24:47 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_user.c,v 1.1.1.8 2002/09/26 18:57:57 hartmans Exp $");
#include "../afs/stds.h"
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#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_DARWIN60_ENV)
#include <netinet/in_var.h>
#endif /* ! AFS_HPUX110_ENV */
#endif /* !defined(UKERNEL) */
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_util.c,v 1.1.1.6 2001/10/14 17:58:58 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_util.c,v 1.1.1.7 2002/09/26 18:57:57 hartmans Exp $");
#include "../afs/stds.h"
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#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_DARWIN60_ENV)
#include <netinet/in_var.h>
#endif /* ! AFS_HPUX110_ENV */
#endif /* !defined(UKERNEL) */
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_vcache.c,v 1.1.1.13 2002/08/02 04:28:44 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_vcache.c,v 1.1.1.14 2002/09/26 18:57:58 hartmans Exp $");
#include "../afs/sysincludes.h" /*Standard vendor system headers*/
#include "../afs/afsincludes.h" /*AFS-based standard headers*/
#ifdef AFS_OSF_ENV
extern struct mount *afs_globalVFS;
extern struct vnodeops Afs_vnodeops;
-#elif defined(AFS_DARWIN_ENV)
+#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
extern struct mount *afs_globalVFS;
#else
extern struct vfs *afs_globalVFS;
cur = head;
while ((cur = cur->next) != head) {
dentry = list_entry(cur, struct dentry, d_alias);
+#ifdef notdef
if (DCOUNT(dentry)) {
this_parent = dentry;
repeat:
goto resume;
}
}
+#endif
if (!DCOUNT(dentry)) {
AFS_GUNLOCK();
tvc->v.v_freelist.tqe_prev=(struct vnode **)0xdeadb;
/*tvc->vrefCount++;*/
#endif
+#ifdef AFS_FBSD_ENV
+ lockinit(&tvc->rwlock, PINOD, "vcache rwlock", 0, 0);
+ cache_purge(AFSTOV(tvc));
+ tvc->v.v_data=tvc;
+ tvc->v.v_tag=VT_AFS;
+ tvc->v.v_usecount++; /* steal an extra ref for now so vfree never happens */
+ /* This extra ref is dealt with above... */
+#endif
/*
* The proper value for mvstat (for root fids) is setup by the caller.
*/
#ifdef AFS_LINUX22_ENV
vcache2inode(avc); /* Set the inode attr cache */
#endif
+#ifdef AFS_DARWIN_ENV
+ osi_VM_Setup(avc,1);
+#endif
} /*afs_ProcessFS*/
#endif
ReleaseWriteLock(&tvc->lock);
#ifdef AFS_DARWIN_ENV
- osi_VM_Setup(tvc);
+ osi_VM_Setup(tvc,0);
#endif
return tvc;
}
}
ReleaseWriteLock(&tvc->lock);
-#ifdef AFS_DARWIN_ENV
- osi_VM_Setup(avc);
-#endif
return tvc;
} /*afs_GetVCache*/
afs_ProcessFS(tvc, &OutStatus, areq);
ReleaseWriteLock(&tvc->lock);
-#ifdef AFS_DARWIN_ENV
- osi_VM_Setup(tvc);
-#endif
return tvc;
}
#endif
#ifdef AFS_DARWIN_ENV
if (tvc)
- osi_VM_Setup(tvc);
+ osi_VM_Setup(tvc, 0);
#endif
return tvc;
} /*afs_FindVCache*/
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_volume.c,v 1.1.1.10 2002/05/10 23:43:27 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afs/afs_volume.c,v 1.1.1.11 2002/09/26 18:57:58 hartmans Exp $");
#include "../afs/stds.h"
#include "../afs/sysincludes.h" /* Standard vendor system headers */
#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_DARWIN60_ENV)
#include <netinet/in_var.h>
#endif /* ! AFS_HPUX110_ENV */
#endif /* !defined(UKERNEL) */
#ifdef AFS_LINUX20_ENV
#define MyPidxx current->pid
#else
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV)
#define MyPidxx (current_proc()->p_pid )
#else
+#if defined(AFS_FBSD_ENV)
+#define MyPidxx (curproc->p_pid )
+#else
#define MyPidxx (u.u_procp->p_pid )
+#endif /* AFS_FBSD_ENV */
#endif /* AFS_DARWIN_ENV */
#endif /* AFS_LINUX20_ENV */
#endif /* AFS_SGI64_ENV */
#include <linux/errno.h>
#else /* AFS_LINUX22_ENV */
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV)
#define _MACH_ETAP_H_
typedef unsigned short etap_event_t;
#endif
#endif /* AFS_DEC_ENV */
-#ifndef AFS_SGI64_ENV
+#if !defined(AFS_SGI64_ENV) && !defined(AFS_FBSD_ENV)
#include "../h/user.h"
#endif /* AFS_SGI64_ENV */
#define MACH_USER_API 1
# include <sys/namei.h>
# include <sys/vnode.h>
# include <sys/queue.h>
+# include <sys/malloc.h>
#ifndef AFS_FBSD_ENV
# include <sys/ubc.h>
#define timeout_fcn_t mach_timeout_fcn_t
# include <kern/sched_prim.h>
#else
+MALLOC_DECLARE(M_AFS);
# include <ufs/ufs/dinode.h>
# include <vm/vm.h>
# include <vm/vm_extern.h>
# include <vm/pmap.h>
# include <vm/vm_map.h>
# include <sys/lock.h>
+# include <sys/user.h>
#endif
#undef timeout_fcn_t
#define _DIR_H_
if [ -f $AFSDOPT ]; then
OPTIONS=`cat $AFSDOPT`
else
- OPTIONS=$MEDIUM
+ OPTIONS="$MEDIUM -fakestat"
+fi
+
+if [ -x /usr/sbin/kmodstat ]; then
+ KMODSTAT=/usr/sbin/kmodstat
+else
+ if [ -x /usr/sbin/kextstat ]; then
+ KMODSTAT=/usr/sbin/kextstat
+fi
fi
# Need the commands ps, awk, kill, sleep
PATH=${PATH}${PATH:+:}/sbin:/bin:/usr/bin
-if kmodstat | grep -q openafs ; then
+if $KMODSTAT | grep -q openafs ; then
:
else
if [ -d $VICEETC/afs.kext ]; then
exit 1
fi
fi
-if kmodstat | grep -q openafs ; then
+if $KMODSTAT | grep -q openafs ; then
:
else
echo "AFS kernel extensions failed to initialize. Skipping AFS startup."
# 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
+VICEETC=/usr/vice/etc
+AFSD=$VICEETC/afsd
CONFIG=$VICEETC/config
AFSDOPT=$CONFIG/afsd.options
PACKAGE=$CONFIG/package.options
# Need the commands ps, awk, kill, sleep
PATH=${PATH}${PATH:+:}/sbin:/bin:/usr/bin
-if kmodstat | grep -q openafs ; then
+if kmodstat | grep -q afs.ko ; then
:
else
-if [ -d $VICEETC/afs.ko ]; then
+if [ -f $VICEETC/afs.ko ]; then
echo "Loading AFS kernel extensions"
kldload $VICEETC/afs.ko
else
exit 1
fi
fi
-if kldstat | grep -q openafs ; then
+if kldstat | grep -q afs.ko ; then
:
else
echo "AFS kernel extensions failed to initialize. Skipping AFS startup."
+ exit
fi
#
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/afsd/afsd.c,v 1.1.1.14 2002/08/02 04:33:53 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afsd/afsd.c,v 1.1.1.15 2002/09/26 19:04:22 hartmans Exp $");
#define VFS 1
#if AFS_HAVE_STATVFS
#include <sys/statvfs.h>
#else
+#if defined(AFS_SUN_ENV)
+#include <sys/vfs.h>
+#else
#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
#include <sys/statfs.h>
#endif
#endif
+#endif
#undef VIRTUE
#undef VICE
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/afsmonitor/afsmonitor.c,v 1.1.1.7 2001/09/11 14:31:07 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/afsmonitor/afsmonitor.c,v 1.1.1.8 2002/09/26 19:04:39 hartmans Exp $");
#include <stdio.h>
#include <math.h>
+#ifndef AFS_FBSD_ENV
/*
strcasestr(): Return first occurence of pattern s2 in s1, case
insensitive.
}
return ((char *)NULL);
}
-
+#endif
struct hostent *GetHostByName(name)
char *name;
memcpy(&(curr_skt->sin_addr.s_addr), he->h_addr, 4);
curr_skt->sin_family = htons(AF_INET); /*Internet family*/
curr_skt->sin_port = htons(7000); /*FileServer port*/
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ curr_skt->sin_len = sizeof(struct sockaddr_in);
+#endif
/* get the next dude */
curr_skt++;
memcpy(&(curr_skt->sin_addr.s_addr), he->h_addr, 4);
curr_skt->sin_family = htons(AF_INET); /*Internet family*/
curr_skt->sin_port = htons(7001); /*Cache Manager port*/
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ curr_skt->sin_len = sizeof(struct sockaddr_in);
+#endif
/* get the next dude */
curr_skt++;
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/auth/cellconfig.c,v 1.1.1.12 2002/01/22 19:52:29 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/auth/cellconfig.c,v 1.1.1.13 2002/09/26 19:04:53 hartmans Exp $");
#include <afs/stds.h>
#include <afs/pthread_glock.h>
#include "cellconfig.h"
#include "keys.h"
+#ifndef T_AFSDB
+#define T_AFSDB 18 /* per RFC1183 section 1 */
+#endif
+
static ParseHostLine();
static ParseCellLine();
static afsconf_OpenInternal();
if (code != 5) return AFSCONF_SYNTAX;
addr->sin_family = AF_INET;
addr->sin_port = 0;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ addr->sin_len = sizeof(struct sockaddr_in);
+#endif
tp = (char *) &addr->sin_addr;
*tp++ = c1;
*tp++ = c2;
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/bozo/bnode.c,v 1.1.1.8 2002/01/22 19:52:31 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/bozo/bnode.c,v 1.1.1.9 2002/09/26 19:04:55 hartmans Exp $");
#include <stddef.h>
#include <stdlib.h>
#include <afs/fileutil.h>
#include "bnode.h"
-#ifdef AFS_AIX_ENV
+#if defined(AFS_AIX_ENV) || defined(AFS_SUN4_ENV)
/* All known versions of AIX lack WCOREDUMP but this works */
#define WCOREDUMP(x) ((x) & 0x80)
#endif
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/bozo/bos.c,v 1.1.1.9 2001/10/14 18:04:04 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/bozo/bos.c,v 1.1.1.10 2002/09/26 19:04:56 hartmans Exp $");
#include <afs/stds.h>
#include <stdlib.h>
cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
add_std_args (ts);
- ts = cmd_CreateSyntax("restart", Restart, 0, "restart all processes");
+ ts = cmd_CreateSyntax("restart", Restart, 0, "restart processes");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
cmd_AddParm(ts, "-bosserver", CMD_FLAG, CMD_OPTIONAL, "restart bosserver");
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/bozo/bosserver.c,v 1.1.1.12 2002/05/10 23:57:25 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/bozo/bosserver.c,v 1.1.1.13 2002/09/26 19:04:58 hartmans Exp $");
#include <afs/stds.h>
#include <sys/types.h>
/* create all the bozo dirs */
static CreateDirs() {
- MakeDir(AFSDIR_USR_DIRPATH);
- MakeDir(AFSDIR_SERVER_AFS_DIRPATH);
+ if ((!strncmp(AFSDIR_USR_DIRPATH, AFSDIR_CLIENT_ETC_DIRPATH,
+ strlen(AFSDIR_USR_DIRPATH))) ||
+ (!strncmp(AFSDIR_USR_DIRPATH, AFSDIR_SERVER_BIN_DIRPATH,
+ strlen(AFSDIR_USR_DIRPATH)))) {
+ MakeDir(AFSDIR_USR_DIRPATH);
+ }
+ if (!strncmp(AFSDIR_SERVER_AFS_DIRPATH, AFSDIR_SERVER_BIN_DIRPATH,
+ strlen(AFSDIR_SERVER_AFS_DIRPATH))) {
+ MakeDir(AFSDIR_SERVER_AFS_DIRPATH);
+ }
MakeDir(AFSDIR_SERVER_BIN_DIRPATH);
MakeDir(AFSDIR_SERVER_ETC_DIRPATH);
MakeDir(AFSDIR_SERVER_LOCAL_DIRPATH);
MakeDir(AFSDIR_SERVER_DB_DIRPATH);
MakeDir(AFSDIR_SERVER_LOGS_DIRPATH);
#ifndef AFS_NT40_ENV
- MakeDir(AFSDIR_CLIENT_VICE_DIRPATH);
+ if (!strncmp(AFSDIR_CLIENT_VICE_DIRPATH, AFSDIR_CLIENT_ETC_DIRPATH,
+ strlen(AFSDIR_CLIENT_VICE_DIRPATH))) {
+ MakeDir(AFSDIR_CLIENT_VICE_DIRPATH);
+ }
MakeDir(AFSDIR_CLIENT_ETC_DIRPATH);
symlink(AFSDIR_SERVER_THISCELL_FILEPATH, AFSDIR_CLIENT_THISCELL_FILEPATH);
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/bucoord/commands.c,v 1.1.1.6 2001/09/11 14:31:33 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/bucoord/commands.c,v 1.1.1.7 2002/09/26 19:05:02 hartmans Exp $");
#include <afs/stds.h>
#include <sys/types.h>
tvd->server.sin_addr.s_addr = entries[e].serverNumber[ei];
tvd->server.sin_port = 0; /* default FS port */
tvd->server.sin_family = AF_INET;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ tvd->server.sin_len = sizeof(struct sockaddr_in);
+#endif
/* String tvd off of partition struct */
tvd->next = ps->vdlist;
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/bucoord/config.c,v 1.1.1.5 2001/09/11 14:31:33 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/bucoord/config.c,v 1.1.1.6 2002/09/26 19:05:03 hartmans Exp $");
#include <sys/types.h>
#ifdef AFS_NT40_ENV
tentry->addr.sin_family = AF_INET;
memcpy(&tentry->addr.sin_addr.s_addr, th->h_addr, sizeof(afs_int32));
tentry->addr.sin_port = 0;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ tentry->addr.sin_len = sizeof(struct sockaddr_in);
+#endif
tentry->portOffset = aport;
return 0;
}
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/bucoord/dsvs.c,v 1.1.1.5 2001/09/11 14:31:35 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/bucoord/dsvs.c,v 1.1.1.6 2002/09/26 19:05:04 hartmans Exp $");
#include <sys/types.h>
#include <afs/cmd.h>
/*
* Four chunks were read, so we assume success. Construct the socket.
*/
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ asockaddr->sin_len=sizeof(struct sockaddr_in);
+#endif
asockaddr->sin_family = AF_INET;
asockaddr->sin_port = 0;
addr = (b1<<24) | (b2<<16) | (b3<<8) | b4;
/*
* We found a mapping; construct the socket.
*/
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ asockaddr->sin_len=sizeof(struct sockaddr_in);
+#endif
asockaddr->sin_family = AF_INET;
asockaddr->sin_port = 0;
memcpy(&tmp1, th->h_addr, sizeof(afs_int32));
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/bucoord/tape_hosts.c,v 1.1.1.5 2001/09/11 14:31:38 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/bucoord/tape_hosts.c,v 1.1.1.6 2002/09/26 19:05:06 hartmans Exp $");
#include <afs/stds.h>
#include <sys/types.h>
the->portOffset = port;
if (th) {
memcpy(&the->addr.sin_addr.s_addr, th->h_addr, 4);
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ the->addr.sin_len = sizeof(struct sockaddr_in);
+#endif
the->addr.sin_family = AF_INET;
the->addr.sin_port = 0;
}
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/butc/dump.c,v 1.1.1.6 2001/09/11 14:31:47 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/butc/dump.c,v 1.1.1.7 2002/09/26 19:05:11 hartmans Exp $");
#include <sys/types.h>
#ifdef AFS_NT40_ENV
else \
sprintf(dumpname, "%s (DumpId %u)", name, dbDumpId);
-#if defined(AFS_NT40_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_NT40_ENV) || (defined(AFS_DARWIN_ENV) && !defined(AFS_DARWIN60_ENV)) || defined(AFS_SUN4_ENV)
localtime_r(t, tm)
time_t *t;
struct tm *tm;
server.sin_addr.s_addr = vldbEntry.serverNumber[e];
server.sin_port = 0;
server.sin_family = AF_INET;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ server.sin_len = sizeof(struct sockaddr_in);
+#endif
curDump->hostAddr = HOSTADDR(&server);
curDump->partition = vldbEntry.serverPartition[e];
+AC_DEFUN(LINUX_EXPORTS_TASKLIST_LOCK, [
+AC_MSG_CHECKING(for exported tasklist_lock)
+save_CPPFLAGS="$CPPFLAGS"
+CPPFLAGS="-I${LINUX_KERNEL_PATH}/include -D__KERNEL__ $CPPFLAGS"
+AC_CACHE_VAL(ac_cv_linux_exports_tasklist_lock,
+[
+AC_TRY_COMPILE(
+[#include <linux/modversions.h>],
+[#ifndef __ver_tasklist_lock
+#error tasklist_lock not exported
+#endif],
+ac_cv_linux_exports_tasklist_lock=yes,
+ac_cv_linux_exports_tasklist_lock=no)])
+AC_MSG_RESULT($ac_cv_linux_exports_tasklist_lock)
+CPPFLAGS="$save_CPPFLAGS"])
+
+AC_DEFUN(LINUX_COMPLETION_H_EXISTS, [
+AC_MSG_CHECKING(for linux/completion.h existance)
+save_CPPFLAGS="$CPPFLAGS"
+CPPFLAGS="-I${LINUX_KERNEL_PATH}/include -D__KERNEL__ $CPPFLAGS"
+AC_CACHE_VAL(ac_cv_linux_completion_h_exists,
+[
+AC_TRY_COMPILE(
+[#include <linux/completion.h>],
+[struct completion _c;],
+ac_cv_linux_completion_h_exists=yes,
+ac_cv_linux_completion_h_exists=no)])
+AC_MSG_RESULT($ac_cv_linux_completion_h_exists)
+CPPFLAGS="$save_CPPFLAGS"])
+
AC_DEFUN(LINUX_FS_STRUCT_INODE_HAS_I_MMAP_SHARED, [
AC_MSG_CHECKING(for i_mmap_shared in struct inode)
save_CPPFLAGS="$CPPFLAGS"
MT_CFLAGS=-D_REENTRANT=1 -pthread -DAFS_PTHREAD_ENV ${XCFLAGS}
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${CC} -all -shared -expect_unresolved "*"
XLIBS=@LIB_AFSDB@
MTLIBS=-pthread -lpthread -lmach -lexc -lc
NON_SHARED=-non_shared
RANLIB=/bin/true
INSTALL=${TOP_SRCDIR}/pinstall/pinstall
CP=cp
+RM=rm
#this is for the vol package
FS_CONV_OSF40D = fs_conv_dux40D
MT_CFLAGS=-D_REENTRANT=1 -pthread -DAFS_PTHREAD_ENV ${XCFLAGS}
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${CC} -all -shared -expect_unresolved "*"
XLIBS=@LIB_AFSDB@
MTLIBS=-pthread -lpthread -lmach -lexc -lc
NON_SHARED=-non_shared
OPTMZ=-O2
DBG=-g3
CP=cp
+RM=rm
CSTATIC=-non_shared
RANLIB=/bin/true
INSTALL=${TOP_SRCDIR}/pinstall/pinstall
# Put -O2 here to _ensure_ all Makefiles pick it up.
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
-XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+XLDFLAGS=#
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
-#
+SHLIB_LINKER=${MT_CC} -shared
# libraries
MTLIBS=-lpthread
TXLIBS= /usr/lib/libncurses.so
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
LEX=/opt/langtools/bin/lex
DBM=/lib/libndbm.a
PAM_CFLAGS=+DA1.0 +z -Wl,+k
-SHARE_LDFLAGS=-b -Bsymbolic
+SHLIB_LDFLAGS=-b -Bsymbolic
PAMLIBS=/usr/lib/libpam.1
YACC=/opt/langtools/bin/yacc
TXLIBS=/usr/lib/libHcurses.a
MTLIBS=-lpthread
SHLIB_SUFFIX=sl
+SHLIB_LDFLAGS=-b -Bsymbolic
+SHLIB_LINKER=ld -b
LWP_OPTMZ=-O
OPTMZ=-O
DBG=-g
LEX=/opt/langtools/bin/lex
DBM=/lib/libndbm.a
PAM_CFLAGS=+DA1.0 +z -Wl,+k
-SHARE_LDFLAGS=-b -Bsymbolic
PAMLIBS=/usr/lib/libpam.1
YACC=/opt/langtools/bin/yacc
XCFLAGS= ${DBG} -Dfds_bits=fd_bits -DAFS_AFSDB_ENV -DAFS_FREELANCE_CLIENT
MT_CFLAGS=${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
#
#
# AFS_OSTYPE used to indicate suffixes and os specific subdirectories.
AFS_OSTYPE = FBSD
-# 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
XCFLAGS= -O2 -pipe
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
#
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS= -fpic
#
XCFLAGS= -O2 -G0
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
#
#MT_CC=cc
KROOT=
KINCLUDES=-I$(KROOT)/System/Library/Frameworks/Kernel.framework/Headers
-#SHARE_LDFLAGS =
LWP_OPTMZ=-g
OPTMZ=-g
DBG=-g
#MT_CC=cc
KROOT=
KINCLUDES=-I$(KROOT)/System/Library/Frameworks/Kernel.framework/Headers
-#SHARE_LDFLAGS =
LWP_OPTMZ=-O2
OPTMZ=-O2
DBG=-g
#MT_CC=cc
KROOT=
KINCLUDES=-I$(KROOT)/System/Library/Frameworks/Kernel.framework/Headers
-#SHARE_LDFLAGS =
LWP_OPTMZ=-O2
OPTMZ=-O2
DBG=-g
MT_CFLAGS=-DAFS_PTHREAD_ENV ${XCFLAGS}
SHLIB_SUFFIX=o
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -bM:SRE -berok
#
# libraries
TXLIBS=-lcurses
XCFLAGS= -O -g
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
XCFLAGS= -O -g
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
XLIBS=@LIB_AFSDB@
MTLIBS=-lpthread
SHLIB_SUFFIX=so
+SHLIB_LINKER=${CC} -shared
#
# programs
AR=ar
XLIBS=@LIB_AFSDB@
MTLIBS=-lpthread
SHLIB_SUFFIX=so
+SHLIB_LINKER=${CC} -shared
#
# programs
AR=ar
MTLIBS=-lpthread
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${CC} -shared
#
# programs
AR=ar
MTLIBS=-lpthread
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${CC} -shared
#
# programs
AR=ar
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
XCFLAGS= -O2
MT_CFLAGS=-DAFS_PTHREAD_ENV -pthread -D_REENTRANT ${XCFLAGS}
XLDFLAGS=
-SHARE_LDFLAGS = -shared -Xlinker -x
+SHLIB_LDFLAGS = -shared -Xlinker -x
SHLIB_SUFFIX=so
SHLIB_CFLAGS=
+SHLIB_LINKER=${MT_CC} -shared
#
# libraries
MTLIBS=-lpthread
LWP_OPTMZ=-g
OPTMZ=-O
DBG=-g
+
+SHLIB_SUFFIX=so
+SHLIB_LINKER=${CC} -G -dy -Wl,-Mmapfile -Bsymbolic -z text
+
#
# libraries
XLIBS=@LIB_AFSDB@ -lsocket -lnsl -lintl -ldl
MT_CFLAGS=-mt -DAFS_PTHREAD_ENV ${XCFLAGS}
PAM_CFLAGS = -KPIC
PAMLIBS= -lc -lpam -lsocket -lnsl -lm
-SHARE_LDFLAGS = -G -Bsymbolic
+SHLIB_LDFLAGS = -G -Bsymbolic
LWP_OPTMZ=-g
OPTMZ=-O
DBG=-g
+
+SHLIB_SUFFIX=so
+SHLIB_LINKER=${CC} -G -dy -Wl,-Mmapfile -Bsymbolic -z text
#
# libraries
XLIBS=@LIB_AFSDB@ -lsocket -lnsl -lintl -ldl
MT_CFLAGS=-mt -DAFS_PTHREAD_ENV ${XCFLAGS}
PAM_CFLAGS = -KPIC
PAMLIBS= -lc -lpam -lsocket -lnsl -lm
-SHARE_LDFLAGS = -G -Bsymbolic
+SHLIB_LDFLAGS = -G -Bsymbolic
LWP_OPTMZ=-g
OPTMZ=-O
DBG=-g
## Compilation flags for 64 bit Solaris
XCFLAGS64 = ${XCFLAGS} -xarch=v9
+SHLIB_SUFFIX=so
+SHLIB_LINKER=${CC} -G -dy -Wl,-Mmapfile -Bsymbolic -z text
+
#
# libraries
XLIBS=@LIB_AFSDB@ -lsocket -lnsl -lintl -ldl
MT_CFLAGS=-mt -DAFS_PTHREAD_ENV ${XCFLAGS}
PAM_CFLAGS = -KPIC
PAMLIBS= -lc -lpam -lsocket -lnsl -lm
-SHARE_LDFLAGS = -G -Bsymbolic
+SHLIB_LDFLAGS = -G -Bsymbolic
LWP_OPTMZ=-g
OPTMZ=-O
DBG=-g
## Compilation flags for 64 bit Solaris
XCFLAGS64 = ${XCFLAGS} -xarch=v9
+SHLIB_SUFFIX=so
+SHLIB_LINKER=${CC} -G -dy -Wl,-Mmapfile -Bsymbolic -z text
#
# libraries
XLIBS=@LIB_AFSDB@ -lsocket -lnsl -lintl -ldl
MT_CFLAGS=-mt -DAFS_PTHREAD_ENV ${XCFLAGS}
PAM_CFLAGS = -KPIC
PAMLIBS= -lc -lpam -lsocket -lnsl -lm
-SHARE_LDFLAGS = -G -Bsymbolic
LWP_OPTMZ=-g
OPTMZ=-O
DBG=-g
XLIBELFA=-lelf
XLIBKVM=-lkvm
#
+SHLIB_LINKER=${CC} -G -dy -Wl,-Mmapfile -Bsymbolic -z text
SHLIB_SUFFIX=so
SHLIB_CFLAGS=-KPIC
+SHLIB_LDFLAGS = -G -Bsymbolic
#
# programs
AR=/usr/ccs/bin/ar
# AFS_OSTYPE used to indicate suffixes and os specific subdirectories.
AFS_OSTYPE = NCR
+SHLIB_SUFFIX=so
+SHLIB_LINKER=${CC} -G -dy -Wl,-Mmapfile -Bsymbolic -z text
+
# compilation and link editor flags
#
# libraries
MT_CFLAGS=-mt -DAFS_PTHREAD_ENV ${XCFLAGS}
PAM_CFLAGS = -KPIC
PAMLIBS= -lc -lpam -lsocket -lnsl -lm
-SHARE_LDFLAGS = -G -Bsymbolic
+SHLIB_LDFLAGS = -G -Bsymbolic
LWP_OPTMZ=-g
OPTMZ=-O
DBG=-g
## Compilation flags for 64 bit Solaris
XCFLAGS64 = ${XCFLAGS} -xarch=v9
+SHLIB_SUFFIX=so
+SHLIB_LINKER=${CC} -G -dy -Wl,-Mmapfile -Bsymbolic -z text
#
# libraries
XLIBS=@LIB_AFSDB@ -lsocket -lnsl -lintl -ldl
#define SYS_NAME_ID_ppc_darwin_12 503
#define SYS_NAME_ID_ppc_darwin_13 504
#define SYS_NAME_ID_ppc_darwin_14 505
+#define SYS_NAME_ID_ppc_darwin_60 506
#define SYS_NAME_ID_next_mach20 601
#define SYS_NAME_ID_next_mach30 602
#define SYS_NAME_ID_alpha_linux_24 2002
#define SYS_NAME_ID_i386_fbsd_42 2100
+#define SYS_NAME_ID_i386_fbsd_43 2101
+#define SYS_NAME_ID_i386_fbsd_44 2102
+#define SYS_NAME_ID_i386_fbsd_45 2103
+#define SYS_NAME_ID_i386_fbsd_46 2103
#define SYS_NAME_ID_ia64_linux2 2200
#define SYS_NAME_ID_ia64_linux22 2201
#define AFS_X86_FBSD42_ENV 1
#define AFS_X86_ENV 1
#define AFS_NONFSTRANS 1
-#define AFS_KERBEROS_ENV 1
#define O_SYNC O_FSYNC
#define FTRUNC O_TRUNC
#define AFS_HAVE_FFS 1 /* Use system's ffs. */
#define AFS_HAVE_STATVFS 0 /* System doesn't supports statvfs */
+#define RXK_LISTENER_ENV 1
#define AFS_GCPAGS 0 /* if nonzero, garbage collect PAGs */
#define AFS_USE_GETTIMEOFDAY 1 /* use gettimeofday to implement rx clock */
#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 AFS_KALLOC(x) malloc(x, M_AFS, M_WAITOK)
+#define AFS_KFREE(x,y) free(x,M_AFS)
#define v_count v_usecount
#define v_vfsp v_mount
#define vfs_bsize mnt_stat.f_bsize
#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
#endif
#endif /* KERNEL */
-#define HAVE_UCONTEXT_H /* should be in afsconfig.h */
+#define USE_UCONTEXT /* should be in afsconfig.h */
#endif /* _PARAM_IA64_LINUX20_H_ */
#define CMSERVERPREF
#endif
-#define HAVE_UCONTEXT_H /* should be in afsconfig.h */
+#define USE_UCONTEXT /* should be in afsconfig.h */
#endif /* AFS_PARAM_H */
#define AFS_AIX41_ENV 1
#define AFS_AIX42_ENV 1
+#ifdef AFS_NAMEI_ENV
+#define AFS_64BIT_IOPS_ENV 1 /* needed for NAMEI... */
+#endif
+
#include <afs/afs_sysnames.h>
/* Global lock in AFS part of client. */
#define ZeroInt64(a) (a) = 0
#define AssignInt64(a, b) *(a) = (b)
#define AddInt64(a,b,c) *(c) = (a) + (b)
-#define SubtractInt64(a,b,c) *(c) = (a) - (b)
-#define CompareInt64(a,b) (a) - (b)
+#define SubtractInt64(a,b,c) *(c) = (afs_int64)(a) - (afs_int64)(b)
+#define CompareInt64(a,b) (afs_int64)(a) - (afs_int64)(b)
#define NonZeroInt64(a) (a)
#define Int64ToInt32(a) (a) & 0xFFFFFFFFL
#define FillInt64(t,h,l) (t) = (h); (t) <<= 32; (t) |= (l);
#define VIOC_STATISTICS _VICEIOCTL(68) /* arla: fetch statistics */
/* Coordinated 'C' pioctl's */
-#define VIOC_NEWALIAS _VICEIOCTL2('C', 1) /* create new cell alias */
-#define VIOC_GETALIAS _VICEIOCTL2('C', 2) /* get alias info */
+#define VIOC_NEWALIAS _CVICEIOCTL(1) /* create new cell alias */
+#define VIOC_GETALIAS _CVICEIOCTL(2) /* get alias info */
#endif /* AFS_VENUS_H */
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/dir/dir.c,v 1.1.1.5 2001/07/14 22:21:40 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/dir/dir.c,v 1.1.1.6 2002/09/26 19:05:59 hartmans Exp $");
#ifdef KERNEL
#if !defined(UKERNEL)
#if defined(AFS_SUN56_ENV) || defined(AFS_HPUX_ENV)
#include "../afs/sysincludes.h"
#endif
-#ifndef AFS_SGI64_ENV
#if defined(AFS_FBSD_ENV)
#include "../h/lock.h"
#include "../vm/vm.h"
#include "../vm/pmap.h"
#include "../vm/vm_map.h"
#endif /* AFS_FBSD_ENV */
+#if !defined(AFS_SGI64_ENV) && !defined(AFS_DARWIN60_ENV)
#include "../h/user.h"
#endif /* AFS_SGI64_ENV */
#include "../h/uio.h"
#include <afs/param.h>
#endif
-RCSID("$Header: /tmp/cvstemp/openafs/src/fsint/afsaux.c,v 1.1.1.6 2002/06/10 11:45:59 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/fsint/afsaux.c,v 1.1.1.7 2002/09/26 19:06:03 hartmans Exp $");
#ifdef KERNEL
#if defined(UKERNEL)
#include "../afs/afsincludes.h"
#include "../rx/xdr.h"
#else /* defined(UKERNEL) */
-#if defined(AFS_ALPHA_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_ALPHA_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
#include "../afs/sysincludes.h"
#include "../afs/afsincludes.h"
#else
#endif
#if (defined(AFS_AIX_ENV) && !defined(AUTH_DES)) || (!defined(AFS_SUN_ENV)) && !defined(AFS_SGI_ENV) && !defined(AFS_ALPHA_ENV) && !defined(AFS_SUN5_ENV)
#ifndef AFS_AIX32_ENV
-#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
/*
* XDR chars; from user mode xdr package.
*/
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/gtx/curseswindows.c,v 1.1.1.5 2001/07/14 22:22:01 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/gtx/curseswindows.c,v 1.1.1.6 2002/09/26 19:06:06 hartmans Exp $");
#if defined(AFS_HPUX110_ENV) && !defined(__HP_CURSES)
struct gator_cursesgwin *cwp; /*Curses-specific data*/
cwp = (struct gator_cursesgwin *)(gwp->w_data);
-#ifdef AFS_DARWIN_ENV
+#if defined(AFS_DARWIN_ENV) && !defined(AFS_DARWIN60_ENV)
aparms->maxx = cwp->wp->maxx;
aparms->maxy = cwp->wp->maxy;
#else
#include <afs/param.h>
#endif
-RCSID("$Header: /tmp/cvstemp/openafs/src/kauth/authclient.c,v 1.1.1.9 2001/10/14 18:05:03 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/kauth/authclient.c,v 1.1.1.10 2002/09/26 19:06:14 hartmans Exp $");
#if defined(UKERNEL)
#include "../afs/sysincludes.h"
explicit_cell_server_list.hostName[i][0] = 0;
explicit_cell_server_list.hostAddr[i].sin_port =
htons(AFSCONF_KAUTHPORT);
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ explicit_cell_server_list.hostAddr[i].sin_len =
+ sizeof(struct sockaddr_in);
+#endif
explicit = 1;
}
else break;
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/kauth/krb_udp.c,v 1.1.1.12 2002/08/02 04:35:18 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/kauth/krb_udp.c,v 1.1.1.13 2002/09/26 19:06:20 hartmans Exp $");
#include <afs/stds.h>
#include <sys/types.h>
krb4name = "kerberos4";
sp = getservbyname(krb4name, "udp");
taddr.sin_family = AF_INET; /* added for NCR port */
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ taddr.sin_len = sizeof(struct sockaddr_in);
+#endif
if ( !sp )
{
/* if kerberos-4 is not available, try "kerberos-iv" */
#/* Copyright (C) 1995, 1989 Transarc Corporation - All rights reserved */
-# $Header: /tmp/cvstemp/openafs/src/libafs/MakefileProto.DARWIN.in,v 1.1.1.5 2002/06/10 11:46:33 hartmans Exp $
+# $Header: /tmp/cvstemp/openafs/src/libafs/MakefileProto.DARWIN.in,v 1.1.1.6 2002/09/26 19:06:44 hartmans Exp $
#
# MakefileProto for Digital Unix systems
#
KDEFS=
DBUG =
DEFINES= -D_KERNEL -DKERNEL -DKERNEL_PRIVATE -DDIAGNOSTIC -DUSE_SELECT -DMACH_USER_API -DMACH_KERNEL
+<ppc_darwin_60>
+KOPTS=-no-cpp-precomp -static -fno-common -finline -fno-keep-inline-functions -force_cpusubtype_ALL -msoft-float -mlong-branch
+<ppc_darwin_14 ppc_darwin_13 ppc_darwin_12>
KOPTS=-no-precomp -static -fno-common -finline -fno-keep-inline-functions -force_cpusubtype_ALL -msoft-float -mlong-branch
+<all>
#CFLAGS=-Werror-implicit-function-declaration -I. -I.. ${KINCLUDES} $(DEFINES) $(KDEFS) $(KOPTS) ${DBUG}
#CFLAGS=-framework Kernel -I. -I.. ${KINCLUDES} $(DEFINES) $(KDEFS) $(KOPTS) ${DBUG}
CFLAGS=-I. -I.. -I${TOP_SRCDIR}/config ${KINCLUDES} $(DEFINES) $(KDEFS) $(KOPTS) ${DBUG} ${OPTMZ}
-#/* Copyright (C) 1995, 1989 Transarc Corporation - All rights reserved */
#
# MakefileProto for FreeBSD systems
#
afskerneldir=@afskerneldir@
SYS_NAME=@AFS_SYSNAME@
-# include config/Makefile.${SYS_NAME}
+include config/Makefile.${SYS_NAME}
# OS specific object files:
AFS_OS_OBJS = \
osi_misc.o \
osi_sleep.o \
osi_vm.o \
- osi_vnodeops.o
+ osi_vnodeops.o \
+ osi_module.o
AFS_OS_NFSOBJS = \
osi_vfsops_nfs.o
# -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
+ -DKLD_MODULE -elf -mpreferred-stack-boundary=2 -I.. -I../afs
DBUG = -O2
DEFINES= -DAFSDEBUG -DKERNEL -DAFS -DVICE -DNFS -DUFS -DINET -DQUOTA -DGETMOUNT
OPTF=${OPT}
# Below this line are targets when in the COMMON directory:
-LIBAFS = libafs.o
-LIBAFSNONFS = libafs.nonfs.o
+LIBAFS = libafs.ko
+LIBAFSNONFS = libafs.nonfs.ko
INST_LIBAFS = ${DESTDIR}${afskerneldir}/${LIBAFS}
INST_LIBAFSNONFS = ${DESTDIR}${afskerneldir}/${LIBAFSNONFS}
DEST_LIBAFS = ${DEST}/root.client/bin/${LIBAFS}
DEST_LIBAFSNONFS = ${DEST}/root.client/bin/${LIBAFSNONFS}
+# Without this line, gmake tries to build libafs.o
+.PHONY: libafs
# libafs: $(LIBAFS) $(LIBAFSNONFS)
-# libafs: $(LIBAFSNONFS)
+libafs: $(LIBAFSNONFS)
# install_libafs: $(INST_LIBAFS) $(INST_LIBAFSNONFS)
-# install_libafs: $(INST_LIBAFSNONFS)
+install_libafs: $(INST_LIBAFSNONFS)
# dest_libafs: $(DEST_LIBAFS) $(DEST_LIBAFSNONFS)
-# dest_libafs: $(DEST_LIBAFSNONFS)
-libafs:
- echo WARNING: No kernel module for ${SYS_NAME}
-
-install_libafs:
- echo WARNING: No kernel module for ${SYS_NAME}
-
-dest_libafs:
- echo WARNING: No kernel module for ${SYS_NAME}
+dest_libafs: $(DEST_LIBAFSNONFS)
$(INST_LIBAFS): $(LIBAFS)
$(INSTALL) -f $? $@
${LIBAFS}: $(AFSAOBJS) $(AFSNFSOBJS)
- $(LD) -r -o ${LIBAFS} ${AFSAOBJS} ${AFSNFSOBJS}
+ $(LD) -r -o ${LIBAFS}.kld ${AFSAOBJS} ${AFSNFSOBJS}
+ gensetdefs ${LIBAFS}.kld
+ $(MAKE) setdef0.o setdef1.o
+ $(LD) -Bshareable -o ${LIBAFS} setdef0.o ${LIBAFS}.kld setdef1.o
${LIBAFSNONFS}: $(AFSAOBJS) $(AFSNONFSOBJS)
- $(LD) -r -o ${LIBAFSNONFS} ${AFSAOBJS} ${AFSNONFSOBJS}
+ $(LD) -r -o ${LIBAFSNONFS}.kld ${AFSAOBJS} ${AFSNONFSOBJS}
+ gensetdefs ${LIBAFSNONFS}.kld
+ $(MAKE) setdef0.o setdef1.o
+ $(LD) -Bshareable -o ${LIBAFSNONFS} setdef0.o ${LIBAFSNONFS}.kld setdef1.o
# Object build rules:
$(CRULE1)
osi_vnodeops.o: $(AFS)/osi_vnodeops.c
$(CRULE1)
+osi_module.o: $(AFS)/osi_module.c
+ $(CRULE1)
+setdef0.o: setdef0.c
+ $(CRULE1)
+setdef1.o: setdef1.c
+ $(CRULE1)
com_err.o
XDROBJS =\
+ xdr.o \
+ xdr_array.o \
xdr_arrayn.o \
xdr_rx.o \
xdr_int64.o \
#
# $ what /opt/langtools/bin/pxdb32
# /opt/langtools/bin/pxdb32:
-# HP92453-02 A.10.0A HP-UX SYMBOLIC DEBUGGER (PXDB) $Revision: 1.1.1.2 $
+# HP92453-02 A.10.0A HP-UX SYMBOLIC DEBUGGER (PXDB) $Revision: 1.1.1.3 $
#
# The problem occurs when -g and -O are both used when compiling des.c.
# The simplest way to work around the problem is to leave out either -g or -O.
$(MAKE) $(LIBUAFS) DESTDIR=${DESTDIR}
AFSWEB/$(LIBAFSWEB): setup_nsafs
-cd AFSWEB; \
+ cd AFSWEB; \
$(MAKE) $(LIBAFSWEB) DESTDIR=${DESTDIR}
AFSWEB/$(LIBAFSWEBKRB): setup_nsafs
${TOP_LIBDIR}/libcmd.a ${TOP_LIBDIR}/libcom_err.a \
${TOP_LIBDIR}/util.a
-LDFLAGS = ${SHARE_LDFLAGS}
+LDFLAGS = ${SHLIB_LDFLAGS}
LIBS = ${TOP_LIBDIR}/libkauth.a ${LIBSA} ${TOP_LIBDIR}/libauth.a \
${AFSLIBS} ${PAMLIBS} @LIB_AFSDB@
KLIBS = ${TOP_LIBDIR}/libkauth.krb.a ${LIBSA} ${TOP_LIBDIR}/libauth.krb.a \
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/pinstall/install.c,v 1.1.1.8 2001/10/14 18:06:07 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/pinstall/install.c,v 1.1.1.9 2002/09/26 19:07:22 hartmans Exp $");
#include <stdio.h>
#include <pwd.h>
struct stat istat, ostat;
extern int errno;
+#if !defined(AFS_DARWIN60_ENV)
extern int sys_nerr;
+#endif
#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
extern char *sys_errlist[];
#endif
#endif /* AFS_HPUX_ENV */
char pnametmp[1024];
int pnamelen;
-#if defined (AFS_AIX_ENV) || defined(AFS_XBSD_ENV)
afs_int32 newcode;
static char diskBuffer[BUFSIZE]; /* must be static to avoid compiler bugs for large stuff */
-#endif
char myHostName[100];
struct timeval tvp[2];
int isDir;
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/ptserver/ptprocs.c,v 1.1.1.9 2002/05/11 00:00:47 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/ptserver/ptprocs.c,v 1.1.1.10 2002/09/26 19:07:27 hartmans Exp $");
#include <afs/stds.h>
#include <ctype.h>
code = pr_ReadEntry(tt, 0, apos, aentry);
if (code) ABORT_WITH(tt,code);
- if (!AccessOK (tt, cid, aentry, PRP_STATUS_MEM, PRP_STATUS_ANY))
+ if (!AccessOK (tt, cid, 0, PRP_STATUS_MEM, 0))
ABORT_WITH(tt,PRPERM);
/* Since prdebugentry is in the form of a prentry not a coentry, we will
/* leave this first for rpc stub */
size = aid->idlist_len;
- if (size <= 0) size = 0;
+ if (size == 0) return 0;
+ if (size < 0) return PRTOOMANY;
aname->namelist_val = (prname *)malloc(size*PR_MAXNAMELEN);
aname->namelist_len = 0;
if (aname->namelist_val == 0) return PRNOMEM;
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/ptserver/testpt.c,v 1.1.1.8 2001/10/14 18:06:14 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/ptserver/testpt.c,v 1.1.1.9 2002/09/26 19:07:29 hartmans Exp $");
#include <ctype.h>
#include <errno.h>
memcpy(&cellinfo.hostAddr[i].sin_addr, th->h_addr, sizeof(afs_int32));
cellinfo.hostAddr[i].sin_family = AF_INET;
cellinfo.hostAddr[i].sin_port = 0;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ cellinfo.hostAddr[i].sin_len = sizeof(struct sockaddr_in);
+#endif
}
cellinfo.numServers = i;
strcpy (cellinfo.name, lcell);
*/
#define CV_INIT(cv,a,b,c)
#define CV_DESTROY(cv)
+#ifdef AFS_DARWIN14_ENV
+#define CV_WAIT(cv, lck) { \
+ int isGlockOwner = ISAFS_GLOCK(); \
+ if (isGlockOwner) AFS_GUNLOCK(); \
+ MUTEX_EXIT(lck); \
+ sleep(cv, PVFS); \
+ if (isGlockOwner) AFS_GLOCK(); \
+ MUTEX_ENTER(lck); \
+ }
+
+#define CV_TIMEDWAIT(cv,lck,t) { \
+ int isGlockOwner = ISAFS_GLOCK(); \
+ if (isGlockOwner) AFS_GUNLOCK(); \
+ MUTEX_EXIT(lck); \
+ tsleep(cv,PVFS, "afs_CV_TIMEDWAIT",t); \
+ if (isGlockOwner) AFS_GLOCK(); \
+ MUTEX_ENTER(lck); \
+ }
+
+#define CV_SIGNAL(cv) wakeup_one(cv)
+#define CV_BROADCAST(cv) wakeup(cv)
+#else
#define CV_WAIT(cv, lck) { \
int isGlockOwner = ISAFS_GLOCK(); \
if (isGlockOwner) AFS_GUNLOCK(); \
#define CV_SIGNAL(cv) thread_wakeup_one((event_t)(cv))
#define CV_BROADCAST(cv) thread_wakeup((event_t)(cv))
+#endif
typedef struct {
struct lock__bsd__ lock;
-/* Copyright Transarc Corporation 1998 - All Rights Reserved
- *
+/*
+ * Copyright 2000, International Business Machines Corporation and others.
+ * All Rights Reserved.
+ *
+ * This software has been released under the terms of the IBM Public
+ * License. For details, see the LICENSE file in the top-level source
+ * directory or online at http://www.openafs.org/dl/license10.html
+ */
+
+/*
* rx_kmutex.h - mutex and condition variable macros for kernel environment.
*
- * DUX implementation.
+ * FBSD implementation.
*/
#ifndef _RX_KMUTEX_H_
#define _RX_KMUTEX_H_
-#ifdef AFS_FBSD40_ENV
-
+#include <sys/systm.h>
+#include <sys/proc.h>
#include <sys/lock.h>
-/* #include <kern/sched_prim.h> */
-/* #include <sys/unix_defs.h> */
#define RX_ENABLE_LOCKS 1
#define AFS_GLOBAL_RXLOCK_KERNEL
#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(); \
+ tsleep(cv, PSOCK, "afs_rx_cv_wait", 0); \
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_TIMEDWAIT(cv,lck,t) { \
+ int isGlockOwner = ISAFS_GLOCK(); \
+ if (isGlockOwner) AFS_GUNLOCK(); \
+ MUTEX_EXIT(lck); \
+ tsleep(cv, PSOCK, "afs_rx_cv_timedwait", t); \
+ 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))
+#define CV_SIGNAL(cv) wakeup_one(cv)
+#define CV_BROADCAST(cv) wakeup(cv)
+#define osi_rxWakeup(cv) wakeup(cv)
+typedef int afs_kcondvar_t;
+
+#define HEAVY_LOCKS
+#ifdef NULL_LOCKS
typedef struct {
- struct simplelock lock;
+ struct proc *owner;
} afs_kmutex_t;
-typedef int afs_kcondvar_t;
-#define osi_rxWakeup(cv) thread_wakeup((vm_offset_t)(cv))
+#define MUTEX_INIT(a,b,c,d) \
+ do { \
+ (a)->owner = 0; \
+ } while(0);
+#define MUTEX_DESTROY(a) \
+ do { \
+ (a)->owner = (struct proc *)-1; \
+ } while(0);
+#define MUTEX_ENTER(a) \
+ do { \
+ osi_Assert((a)->owner == 0); \
+ (a)->owner = curproc; \
+ } while(0);
+#define MUTEX_TRYENTER(a) \
+ ( osi_Assert((a)->owner == 0), (a)->owner = curproc, 1)
+#define MUTEX_EXIT(a) \
+ do { \
+ osi_Assert((a)->owner == curproc); \
+ (a)->owner = 0; \
+ } while(0);
-#define LOCK_INIT(a,b) \
+#undef MUTEX_ISMINE
+#define MUTEX_ISMINE(a) (((afs_kmutex_t *)(a))->owner == curproc)
+
+#else
+#ifdef HEAVY_LOCKS
+typedef struct {
+ struct lock lock;
+ struct proc *owner;
+} afs_kmutex_t;
+
+
+#define MUTEX_INIT(a,b,c,d) \
+ do { \
+ lockinit(&(a)->lock,PSOCK, "afs rx mutex", 0, 0); \
+ (a)->owner = 0; \
+ } while(0);
+#define MUTEX_DESTROY(a) \
do { \
- usimple_lock_init(&(a)->lock); \
+ (a)->owner = (struct proc *)-1; \
} while(0);
+#define MUTEX_ENTER(a) \
+ do { \
+ lockmgr(&(a)->lock, LK_EXCLUSIVE, 0, curproc); \
+ osi_Assert((a)->owner == 0); \
+ (a)->owner = curproc; \
+ } while(0);
+#define MUTEX_TRYENTER(a) \
+ ( lockmgr(&(a)->lock, LK_EXCLUSIVE|LK_NOWAIT, 0, curproc) ? 0 : ((a)->owner = curproc, 1) )
+#define xMUTEX_TRYENTER(a) \
+ ( osi_Assert((a)->owner == 0), (a)->owner = curproc, 1)
+#define MUTEX_EXIT(a) \
+ do { \
+ osi_Assert((a)->owner == curproc); \
+ (a)->owner = 0; \
+ lockmgr(&(a)->lock, LK_RELEASE, 0, curproc); \
+ } while(0);
+
+#undef MUTEX_ISMINE
+#define MUTEX_ISMINE(a) (((afs_kmutex_t *)(a))->owner == curproc)
+#else
+typedef struct {
+ struct simplelock lock;
+ struct proc *owner;
+} afs_kmutex_t;
+
+
#define MUTEX_INIT(a,b,c,d) \
do { \
- usimple_lock_init(&(a)->lock); \
+ simple_lock_init(&(a)->lock); \
+ (a)->owner = 0; \
} while(0);
#define MUTEX_DESTROY(a) \
do { \
- usimple_lock_terminate(&(a)->lock); \
+ (a)->owner = (struct proc *)-1; \
} while(0);
#define MUTEX_ENTER(a) \
do { \
- usimple_lock(&(a)->lock); \
+ simple_lock(&(a)->lock); \
+ osi_Assert((a)->owner == 0); \
+ (a)->owner = curproc; \
} while(0);
#define MUTEX_TRYENTER(a) \
- usimple_lock(&(a)->lock)
+ ( simple_lock_try(&(a)->lock) ? 0 : ((a)->owner = curproc, 1) )
#define MUTEX_EXIT(a) \
do { \
- usimple_unlock(&(a)->lock); \
+ osi_Assert((a)->owner == curproc); \
+ (a)->owner = 0; \
+ simple_unlock(&(a)->lock); \
} while(0);
#undef MUTEX_ISMINE
-#define MUTEX_ISMINE(a) 1
-/*
- #define MUTEX_ISMINE(a)
- (((afs_kmutex_t *)(a))->owner == current_thread())
-*/
+#define MUTEX_ISMINE(a) (((afs_kmutex_t *)(a))->owner == curproc)
+#endif
+#endif
+
#undef osirx_AssertMine
extern void osirx_AssertMine(afs_kmutex_t *lockaddr, char *msg);
-#endif /* FBSD40 */
-
-
#endif /* _RX_KMUTEX_H_ */
-
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/rx/FBSD/rx_knet.c,v 1.1.1.4 2001/09/11 14:34:30 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/rx/FBSD/rx_knet.c,v 1.1.1.5 2002/09/26 19:07:44 hartmans Exp $");
#ifdef AFS_FBSD40_ENV
#include "../rx/rx_kcommon.h"
+#ifdef RXK_LISTENER_ENV
+int osi_NetReceive(osi_socket so, struct sockaddr_in *addr, struct iovec *dvec,
+ int nvecs, int *alength)
+{
+ struct socket *asocket = (struct socket *)so;
+ struct uio u;
+ int i;
+ struct iovec iov[RX_MAXIOVECS];
+ struct sockaddr *sa;
+ int code;
+
+ int haveGlock = ISAFS_GLOCK();
+ /*AFS_STATCNT(osi_NetReceive);*/
+
+ if (nvecs > RX_MAXIOVECS) {
+ osi_Panic("osi_NetReceive: %d: Too many iovecs.\n", nvecs);
+ }
+
+ for (i = 0 ; i < nvecs ; i++) {
+ iov[i].iov_base = dvec[i].iov_base;
+ iov[i].iov_len = dvec[i].iov_len;
+ }
+
+ u.uio_iov=&iov[0];
+ u.uio_iovcnt=nvecs;
+ u.uio_offset=0;
+ u.uio_resid=*alength;
+ u.uio_segflg=UIO_SYSSPACE;
+ u.uio_rw=UIO_READ;
+ u.uio_procp=NULL;
+
+ if (haveGlock) {
+ AFS_GUNLOCK();
+ }
+ code = soreceive(asocket, &sa, &u, NULL, NULL, NULL);
+#if KNET_DEBUG
+ if (code) {
+ if (code == EINVAL)
+ Debugger("afs NetReceive busted");
+ else
+ printf("y");
+ }
+#endif
+ if (haveGlock) {
+ AFS_GLOCK();
+ }
+ *alength=*alength-u.uio_resid;
+ if (sa) {
+ if (sa->sa_family == AF_INET) {
+ if (addr) *addr=*(struct sockaddr_in *)sa;
+ } else {
+ printf("Unknown socket family %d in NetReceive\n", sa->sa_family);
+ }
+ }
+ return code;
+}
+
+extern int rxk_ListenerPid;
+void osi_StopListener(void)
+{
+ struct proc *p;
+
+ soclose(rx_socket);
+ p=pfind(rxk_ListenerPid);
+ if (p)
+ psignal(p, SIGUSR1);
+}
+
+int
+osi_NetSend(asocket, addr, dvec, nvecs, alength, istack)
+ register struct socket *asocket;
+ struct iovec *dvec;
+ int nvecs;
+ register afs_int32 alength;
+ struct sockaddr_in *addr;
+ int istack;
+{
+ register afs_int32 code;
+ int s;
+ int len;
+ int i;
+ struct iovec iov[RX_MAXIOVECS];
+ char *tdata;
+ struct uio u;
+ int haveGlock = ISAFS_GLOCK();
+
+ AFS_STATCNT(osi_NetSend);
+ if (nvecs > RX_MAXIOVECS) {
+ osi_Panic("osi_NetSend: %d: Too many iovecs.\n", nvecs);
+ }
+
+ for (i = 0 ; i < nvecs ; i++) {
+ iov[i].iov_base = dvec[i].iov_base;
+ iov[i].iov_len = dvec[i].iov_len;
+ }
+
+ u.uio_iov=&iov[0];
+ u.uio_iovcnt=nvecs;
+ u.uio_offset=0;
+ u.uio_resid=alength;
+ u.uio_segflg=UIO_SYSSPACE;
+ u.uio_rw=UIO_WRITE;
+ u.uio_procp=NULL;
+
+ addr->sin_len=sizeof(struct sockaddr_in);
+
+ if (haveGlock) {
+ AFS_GUNLOCK();
+ }
+#if KNET_DEBUG
+ printf("+");
+#endif
+ code = sosend(asocket, addr, &u, NULL, NULL, 0, curproc);
+#if KNET_DEBUG
+ if (code) {
+ if (code == EINVAL)
+ Debugger("afs NetSend busted");
+ else
+ printf("z");
+ }
+#endif
+ if (haveGlock) {
+ AFS_GLOCK();
+ }
+ return code;
+}
+#else
+/* This code *almost* works :( */
static struct protosw parent_proto; /* udp proto switch */
static void rxk_input (struct mbuf *am, int iphlen);
static void rxk_fasttimo (void);
last = inetdomain.dom_protoswNPROTOSW;
for (tpro = inetdomain.dom_protosw; tpro < last; tpro++)
if (tpro->pr_protocol == IPPROTO_UDP) {
+#if 0 /* not exported */
/* force UDP checksumming on for AFS */
extern int udpcksum;
udpcksum = 1;
+#endif
memcpy(&parent_proto, tpro, sizeof(parent_proto));
tpro->pr_input = rxk_input;
tpro->pr_fasttimo = rxk_fasttimo;
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
return 0;
}
+/* We only have to do all the mbuf management ourselves if we can be called at
+ interrupt time. in RXK_LISTENER_ENV, we can just call sosend() */
int
osi_NetSend(asocket, addr, dvec, nvec, asize, istack)
register struct socket *asocket;
int i,tl,rlen;
int mlen;
int haveGlock;
+#if KNET_DEBUG
+ static int before=0;
+#endif
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();
+ if (trysblock(&asocket->so_snd)) {
+ splx(s);
+ return 1;
+ }
mp = ⊤
i = 0;
tdata = dvec[i].iov_base;
if (top == 0) {
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (!m) {
+ sbunlock(&asocket->so_snd);
splx(s);
return 1;
}
* 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)
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 */
+ sbunlock(&asocket->so_snd);
splx(s);
return 1;
}
memcpy(mtod(um, caddr_t), addr, sizeof(*addr));
- um->m_len = sizeof(*addr);
+ addr->sin_len = 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. */
+ * around it is gone. */
/* haveGlock = ISAFS_GLOCK();
if (haveGlock) {
AFS_GUNLOCK();
} */
/* SOCKET_LOCK(asocket); */
/* code = (*asocket->so_proto->pr_usrreq)(asocket, PRU_SEND, tm, um, 0); */
+#if KNET_DEBUG
+ if (before) Debugger("afs NetSend before");
+#endif
code = (*asocket->so_proto->pr_usrreqs->pru_send)(asocket, 0, tm,
(struct sockaddr *) addr,
- um, curproc);
+ um, &proc0);
/* SOCKET_UNLOCK(asocket); */
/* if (haveGlock) {
AFS_GLOCK();
} */
+ sbunlock(&asocket->so_snd);
splx(s);
- m_free(um);
-
+#if KNET_DEBUG
+ if (code) {
+ if (code == EINVAL)
+ Debugger("afs NetSend busted");
+ else
+ printf("z");
+ }
+#endif
return code;
}
+#endif
#endif /* AFS_FBSD40_ENV */
int owner;
} afs_kmutex_t;
+#ifndef set_current_state
+#define set_current_state(X) current->state=X
+#endif
+
#if defined(AFS_LINUX24_ENV)
typedef wait_queue_head_t afs_kcondvar_t;
#else
/* Set the connection dead time for any connections created for this service (server only) */
#define rx_SetServiceDeadTime(service, seconds) ((service)->secondsUntilDead = (seconds))
+/* Enable or disable asymmetric client checking for a service */
+#define rx_SetCheckReach(service, x) ((service)->checkReach = (x))
+
/* Set connection dead time, for a specific client or server connection */
extern void rx_SetConnDeadTime();
u_short minProcs; /* Minimum # of requests guaranteed executable simultaneously */
u_short connDeadTime; /* Seconds until a client of this service will be declared dead, if it is not responding */
u_short idleDeadTime; /* Time a server will wait for I/O to start up again */
+ u_char checkReach; /* Check for asymmetric clients? */
};
#endif /* KDUMP_RX_LOCK */
afs_hyper_t bytesSent; /* Number of bytes sent to this peer */
afs_hyper_t bytesReceived; /* Number of bytes received from this peer */
struct rx_queue rpcStats; /* rpc statistic list */
+ int lastReachTime; /* Last time we verified reachability */
};
/* A connection is an authenticated communication path, allowing
/* peer process could be restarted on us. Includes RX Header. */
struct rxevent *challengeEvent; /* Scheduled when the server is challenging a */
struct rxevent *delayedAbortEvent; /* Scheduled to throttle looping client */
+ struct rxevent *checkReachEvent; /* Scheduled when checking reachability */
int abortCount; /* count of abort messages sent */
/* client-- to retransmit the challenge */
struct rx_service *service; /* used by servers only */
#define RX_CONN_KNOW_WINDOW 8 /* window size negotiation works */
#define RX_CONN_RESET 16 /* connection is reset, remove */
#define RX_CONN_BUSY 32 /* connection is busy; don't delete */
+#define RX_CONN_ATTACHWAIT 64 /* attach waiting for peer->lastReach */
/* Type of connection, client or server */
#define RX_CLIENT_CONNECTION 0
#define RX_CHALLENGE_TIMEOUT 2 /* Number of seconds before another authentication request packet is generated */
#define RX_CHALLENGE_MAXTRIES 50 /* Max # of times we resend challenge */
+#define RX_CHECKREACH_TIMEOUT 2 /* Number of seconds before another ping is generated */
+#define RX_CHECKREACH_TTL 60 /* Re-check reachability this often */
/* RX error codes. RX uses error codes from -1 to -64. Rxgen may use other error codes < -64; user programs are expected to return positive error codes */
#include <afsconfig.h>
#include "../afs/param.h"
-RCSID("$Header: /tmp/cvstemp/openafs/src/rx/rx_kcommon.c,v 1.1.1.12 2002/06/10 11:47:11 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/rx/rx_kcommon.c,v 1.1.1.13 2002/09/26 19:07:36 hartmans Exp $");
#include "../rx/rx_kcommon.h"
pp->ifMTU = RX_REMOTE_PACKET_SIZE;
}
#else /* AFS_USERSPACE_IP_ADDR */
+#ifdef AFS_DARWIN60_ENV
+ struct ifaddr *ifad = (struct ifaddr *) 0;
+#else
struct in_ifaddr *ifad = (struct in_ifaddr *) 0;
+#endif
struct ifnet *ifn;
/* At some time we need to iterate through rxi_FindIfnet() to find the
}
return different;
}
+#ifdef AFS_DARWIN60_ENV
+/* Returns ifnet which best matches address */
+struct ifnet *
+rxi_FindIfnet(addr, pifad)
+ afs_uint32 addr;
+ struct ifaddr **pifad;
+{
+ struct sockaddr_in s;
+
+ if (numMyNetAddrs == 0)
+ (void) rxi_GetIFInfo();
+ s.sin_family=AF_INET;
+ s.sin_addr.s_addr=addr;
+ *pifad=ifa_ifwithnet((struct sockaddr *)&s);
+ done:
+ return (*pifad ? (*pifad)->ifa_ifp : NULL );
+}
+#else
/* Returns ifnet which best matches address */
struct ifnet *
rxi_FindIfnet(addr, pifad)
done:
return (*pifad ? (*pifad)->ia_ifp : NULL );
}
+#endif
#endif /* else AFS_USERSPACE_IP_ADDR */
#endif /* !SUN5 && !SGI62 */
myaddr.sin_family = AF_INET;
myaddr.sin_port = aport;
myaddr.sin_addr.s_addr = 0;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ myaddr.sin_len = sizeof(myaddr);
+#endif
#ifdef AFS_HPUX110_ENV
bindnam = allocb_wait((addrsize+SO_MSGOFFSET+1), BPRI_MED);
osi_Panic("osi_NewSocket: last attempt to reserve 32K failed!\n");
}
#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
- myaddr.sin_len = sizeof(myaddr);
#if defined(AFS_XBSD_ENV)
code = sobind(newSocket, (struct sockaddr *)&myaddr, curproc);
#else
#ifdef AFS_SUN5_ENV
rxk_ListenerPid = ttoproc(curthread)->p_pidp->pid_id;
#endif /* AFS_SUN5_ENV */
-#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#ifdef AFS_FBSD_ENV
+ rxk_ListenerPid = curproc->p_pid;
+#endif /* AFS_FBSD_ENV */
+#if defined(AFS_DARWIN_ENV)
rxk_ListenerPid = current_proc()->p_pid;
#endif
#if defined(RX_ENABLE_LOCKS) && !defined(AFS_SUN5_ENV)
#ifdef AFS_SGI62_ENV
#include "../h/hashing.h"
#endif
+#ifdef AFS_FBSD_ENV
+#include "../h/sysctl.h"
+#endif
#include "../netinet/in.h"
#include "../net/route.h"
#include "../netinet/in_systm.h"
#include "../netinet/ip.h"
-#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX22_ENV)
+#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN60_ENV)
#include "../netinet/in_pcb.h"
#endif /* ! AFS_HPUX110_ENV && ! AFS_LINUX22_ENV */
#ifndef AFS_LINUX22_ENV
+#if !defined(AFS_DARWIN60_ENV)
#include "../netinet/ip_var.h"
+#endif
#include "../netinet/ip_icmp.h"
#endif /* AFS_LINUX22_ENV */
#include "../netinet/udp.h"
-#if !defined(AFS_SGI62_ENV) && !defined(AFS_LINUX22_ENV)
+#if !defined(AFS_SGI62_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN60_ENV)
#include "../netinet/udp_var.h"
#endif
#if defined(AFS_HPUX102_ENV) || (defined(AFS_SGI62_ENV) && !defined(AFS_SGI64_ENV))
#include "../h/file.h"
#endif
#include "../net/if.h"
-#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX22_ENV)
+#if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN60_ENV)
#include "../netinet/in_var.h"
#endif /* ! AFS_HPUX110_ENV && ! AFS_LINUX22_ENV */
#ifndef AFS_LINUX22_ENV
#ifndef MUTEX_ISMINE
/* Only used for debugging. */
#ifdef AFS_SUN5_ENV
+/* synch.h says mutex_t and pthread_mutex_t are always the same */
#include <synch.h>
-#define MUTEX_ISMINE(l) MUTEX_HELD(l)
+#define MUTEX_ISMINE(l) MUTEX_HELD((mutex_t *) l)
#else /* AFS_SUN5_ENV */
#define MUTEX_ISMINE(l) (1)
#endif /* AFS_SUN5_ENV */
#ifdef MUTEX_INIT
#undef MUTEX_INIT
#endif
-#define MUTEX_INIT(a, b, c, d) pthread_mutex_init(a, NULL)
+#define MUTEX_INIT(a, b, c, d) osi_Assert(pthread_mutex_init(a, NULL) == 0)
#ifdef MUTEX_DESTROY
#undef MUTEX_DESTROY
#endif
-#define MUTEX_DESTROY(l) pthread_mutex_destroy(l)
+#define MUTEX_DESTROY(l) osi_Assert(pthread_mutex_destroy(l) == 0)
#ifdef MUTEX_ENTER
#undef MUTEX_ENTER
#endif
-#define MUTEX_ENTER(l) pthread_mutex_lock(l)
+#define MUTEX_ENTER(l) osi_Assert(pthread_mutex_lock(l) == 0)
#ifdef MUTEX_TRYENTER
#undef MUTEX_TRYENTER
#ifdef MUTEX_EXIT
#undef MUTEX_EXIT
#endif
-#define MUTEX_EXIT(l) pthread_mutex_unlock(l)
+#define MUTEX_EXIT(l) osi_Assert(pthread_mutex_unlock(l) == 0)
#ifdef RXObtainWriteLock
#undef RXObtainWriteLock
#ifdef CV_INIT
#undef CV_INIT
#endif
-#define CV_INIT(cv, a, b, c) pthread_cond_init(cv, NULL)
+#define CV_INIT(cv, a, b, c) osi_Assert(pthread_cond_init(cv, NULL) == 0)
#ifdef CV_DESTROY
#undef CV_DESTROY
#endif
-#define CV_DESTROY(cv) pthread_cond_destroy(cv)
+#define CV_DESTROY(cv) osi_Assert(pthread_cond_destroy(cv) == 0)
#ifdef CV_WAIT
#undef CV_WAIT
#endif
-#define CV_WAIT(cv, l) pthread_cond_wait(cv, l)
+#define CV_WAIT(cv, l) osi_Assert(pthread_cond_wait(cv, l) == 0)
#ifdef CV_SIGNAL
#undef CV_SIGNAL
#endif
-#define CV_SIGNAL(cv) pthread_cond_signal(cv)
+#define CV_SIGNAL(cv) osi_Assert(pthread_cond_signal(cv) == 0)
#ifdef CV_BROADCAST
#undef CV_BROADCAST
#endif
-#define CV_BROADCAST(cv) pthread_cond_broadcast(cv)
+#define CV_BROADCAST(cv) osi_Assert(pthread_cond_broadcast(cv) == 0)
#endif /* AFS_PTHREAD_ENV */
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/rx/rx_user.c,v 1.1.1.6 2001/09/11 14:34:25 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/rx/rx_user.c,v 1.1.1.7 2002/09/26 19:07:39 hartmans Exp $");
# include <sys/types.h>
# include <errno.h>
taddr.sin_addr.s_addr = 0;
taddr.sin_family = AF_INET;
taddr.sin_port = (u_short)port;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ taddr.sin_len = sizeof(struct sockaddr_in);
+#endif
#define MAX_RX_BINDS 10
for (binds=0; binds<MAX_RX_BINDS; binds++) {
if (binds) rxi_Delay (10);
extern void osi_AssertFailU(const char *expr, const char *file, int line);
#define osi_Assert(e) (void)((e) || (osi_AssertFailU(#e, __FILE__, __LINE__), 0))
-#if !defined(_ANSI_C_SOURCE) || defined(AFS_SUN_ENV)
-#if defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)
-extern int fprintf();
-#endif
-#endif /* ANSI_C_SOURCE */
-
#define osi_Msg fprintf)(stderr,
#endif /* RX_USER_INCLUDE */
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/rx/rxdebug.c,v 1.1.1.7 2001/09/11 14:34:25 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/rx/rxdebug.c,v 1.1.1.8 2002/09/26 19:07:40 hartmans Exp $");
#include <sys/types.h>
#include <errno.h>
taddr.sin_family = AF_INET;
taddr.sin_port = 0;
taddr.sin_addr.s_addr = 0;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ taddr.sin_len = sizeof(struct sockaddr_in);
+#endif
code = bind(s, (struct sockaddr *) &taddr, sizeof(struct sockaddr_in));
if (code) {
perror("bind");
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/rxdebug/rxdebug.c,v 1.1.1.2 2001/10/14 18:06:32 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/rxdebug/rxdebug.c,v 1.1.1.3 2002/09/26 19:07:53 hartmans Exp $");
#include <sys/types.h>
#include <errno.h>
taddr.sin_family = AF_INET;
taddr.sin_port = 0;
taddr.sin_addr.s_addr = 0;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ taddr.sin_len = sizeof(struct sockaddr_in);
+#endif
code = bind(s, (struct sockaddr *) &taddr, sizeof(struct sockaddr_in));
if (code) {
perror("bind");
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/rxgen/rpc_main.c,v 1.1.1.10 2002/06/10 11:47:26 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/rxgen/rpc_main.c,v 1.1.1.11 2002/09/26 19:07:55 hartmans Exp $");
#include <limits.h>
#include <stdio.h>
static char *cmdname;
#ifdef AFS_SUN5_ENV
static char CPP[] = "/usr/ccs/lib/cpp";
-#elif defined(AFS_XBSD_ENV)
+#elif defined(AFS_XBSD_ENV) || defined(AFS_DARWIN60_ENV)
static char CPP[] = "/usr/bin/cpp";
#elif defined(AFS_NT40_ENV)
static char CPP[MAXCMDLINE];
#include <afs/param.h>
#endif
-RCSID("$Header: /tmp/cvstemp/openafs/src/rxkad/rxkad_client.c,v 1.1.1.8 2002/06/10 11:47:28 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/rxkad/rxkad_client.c,v 1.1.1.9 2002/09/26 19:07:58 hartmans Exp $");
#ifdef KERNEL
#include "../afs/stds.h"
memcpy((void *)tcp->ivec, (void *)sessionkey, sizeof(tcp->ivec));
tcp->kvno = kvno; /* key version number */
tcp->ticketLen = ticketLen; /* length of ticket */
+ if (tcp->ticketLen > MAXKTCTICKETLEN) return 0; /* bad key */
memcpy(tcp->ticket, ticket, ticketLen);
LOCK_RXKAD_STATS
#include <sys/time_impl.h>
#endif
-RCSID("$Header: /tmp/cvstemp/openafs/src/rxkad/rxkad_common.c,v 1.1.1.10 2002/08/02 04:36:36 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/rxkad/rxkad_common.c,v 1.1.1.11 2002/09/26 19:07:58 hartmans Exp $");
#ifdef KERNEL
#ifndef UKERNEL
#ifdef AFS_AIX_ENV
#include "../h/systm.h"
#endif
+#ifdef AFS_DARWIN60_ENV
+#include "../h/kernel.h"
+#endif
#include "../h/types.h"
#include "../h/time.h"
#ifndef AFS_LINUX22_ENV
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/usd/usd_file.c,v 1.1.1.9 2001/10/14 18:06:52 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/usd/usd_file.c,v 1.1.1.10 2002/09/26 19:08:48 hartmans Exp $");
#include <errno.h>
#include <fcntl.h>
#ifdef AFS_DARWIN_ENV
#include <sys/ioccom.h>
#endif
-#include <sys/mtio.h>
-#endif /* AFS_AIX_ENV */
-#if defined(AFS_DUX40_ENV) || defined(AFS_OBSD_ENV)
+#if defined(AFS_DUX40_ENV) || defined(AFS_OBSD_ENV) || defined(AFS_SUN4_ENV)
#include <sys/ioctl.h>
#endif
+#include <sys/mtio.h>
+#endif /* AFS_AIX_ENV */
#include <afs/debug.h>
#include "usd.h"
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/uss/uss_vol.c,v 1.1.1.5 2001/09/11 14:35:07 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/uss/uss_vol.c,v 1.1.1.6 2002/09/26 19:08:53 hartmans Exp $");
#include "uss_vol.h" /*Interface to this module*/
#include "uss_common.h" /*Common definitions*/
*/
MapHostToNetwork(&vldbEntry);
if (vldbEntry.volumeId[RWVOL] != volID) {
- printf("s: Volume '%s' (ID %d) is not a read/write volume!!\n",
+ printf("%s: Volume '%s' (ID %d) is not a read/write volume!!\n",
uss_whoami, uss_Volume, volID);
return(-1);
}
#include <sys/time.h>
#endif
-RCSID("$Header: /tmp/cvstemp/openafs/src/util/assert.c,v 1.1.1.5 2001/10/14 18:07:00 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/util/assert.c,v 1.1.1.6 2002/09/26 19:08:55 hartmans Exp $");
#include <stdio.h>
+#include "afsutil.h"
#ifdef AFS_NT40_ENV
void afs_NTAbort(void)
time_t when;
time(&when);
- strcpy(tdate, ctime(&when));
- tdate[24] = '0';
+ afs_ctime(&when, tdate, 25);
fprintf(stderr, "%s: Assertion failed! file %s, line %d.\n",
tdate, file, line);
fflush(stderr);
#include <afs/param.h>
#endif
-RCSID("$Header: /tmp/cvstemp/openafs/src/util/netutils.c,v 1.1.1.6 2001/09/11 14:35:15 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/util/netutils.c,v 1.1.1.7 2002/09/26 19:08:58 hartmans Exp $");
#include <stdlib.h>
#include <stdio.h>
/* For each line in the NetInfo file */
while ( fgets(line, MAX_NETFILE_LINE, fp) != NULL ) {
- lineNo++; /* input line number */
- addr = extract_Addr(line, MAX_NETFILE_LINE);
+ int fake=0;
+
+ /* See if first char is an 'F' for fake */
+ /* Added to allow the fileserver to advertise fake IPS for use with
+ * the translation tables for NAT-like firewalls - defect 12462 */
+ for (fake=0; ((fake < strlen(line)) && isspace(line[fake])); fake++);
+ if ( (fake < strlen(line)) && ((line[fake]=='f') || (line[fake]=='F'))) {
+ fake++;
+ } else {
+ fake = 0;
+ }
+
+ lineNo++; /* input line number */
+ addr = extract_Addr(&line[fake], strlen(&line[fake]));
- if (addr == AFS_IPINVALID) { /* syntactically invalid */
- fprintf(stderr,"afs:%s : line %d : parse error\n", fileName, lineNo);
- continue;
- }
- if (addr == AFS_IPINVALIDIGNORE) { /* ignore error */
- continue;
- }
+ if (addr == AFS_IPINVALID) { /* syntactically invalid */
+ fprintf(stderr,"afs:%s : line %d : parse error\n", fileName, lineNo);
+ continue;
+ }
+ if (addr == AFS_IPINVALIDIGNORE) { /* ignore error */
+ continue;
+ }
- /* See if it is an address that really exists */
- for (i=0; i < existNu; i++) {
- if (existingAddr[i] == addr) break;
- }
- if (i >= existNu) continue; /* not found - ignore */
+ /* See if it is an address that really exists */
+ for (i=0; i < existNu; i++) {
+ if (existingAddr[i] == addr) break;
+ }
+ if ((i >= existNu) && (!fake)) continue; /* not found/fake - ignore */
- /* Check if it is a duplicate address we alread have */
- for (l=0; l < count; l++) {
- if ( final[l] == addr ) break;
- }
- if (l < count) {
- fprintf(stderr,"afs:%x specified twice in NetInfo file\n", ntohl(addr));
- continue; /* duplicate addr - ignore */
- }
+ /* Check if it is a duplicate address we alread have */
+ for (l=0; l < count; l++) {
+ if ( final[l] == addr ) break;
+ }
+ if (l < count) {
+ fprintf(stderr,"afs:%x specified twice in NetInfo file\n", ntohl(addr));
+ continue; /* duplicate addr - ignore */
+ }
- if ( count == max ) { /* no more space */
- fprintf(stderr,"afs:Too many interfaces. The current kernel configuration supports a maximum of %d interfaces\n", max);
- } else {
- final[count] = existingAddr[i];
- mask[count] = existingMask[i];
- mtu[count] = existingMtu[i];
- count++;
- }
+ if ( count > max ) { /* no more space */
+ fprintf(stderr,"afs:Too many interfaces. The current kernel configuration supports a maximum of %d interfaces\n", max);
+ } else if (fake) {
+ fprintf(stderr, "Client (2) also has address %s\n", line);
+ final[count] = addr;
+ mask[count] = 0xffffffff;
+ mtu[count] = htonl(1500);
+ count++;
+ } else {
+ final[count] = existingAddr[i];
+ mask[count] = existingMask[i];
+ mtu[count] = existingMtu[i];
+ count++;
+ }
} /* while */
/* in case of any error, we use all the interfaces present */
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/util/readdir_nt.c,v 1.1.1.4 2001/07/14 22:24:25 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/util/readdir_nt.c,v 1.1.1.5 2002/09/26 19:08:59 hartmans Exp $");
#include <errno.h>
#include <afs/errmap_nt.h>
/* opendir() - The case insensitive version of opendir */
DIR *opendir(const char *path)
{
- struct DIR *tDir;
+ DIR *tDir;
HANDLE tH;
char tPath[MAX_PATH];
WIN32_FIND_DATA tData;
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/util/snprintf.c,v 1.1.1.5 2001/07/14 22:24:27 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/util/snprintf.c,v 1.1.1.6 2002/09/26 19:09:00 hartmans Exp $");
-#if defined(AFS_OSF20_ENV) && !defined(AFS_DUX50_ENV) || defined(AFS_AIX32_ENV) || (defined(AFS_SUN55_ENV) && !defined(AFS_SUN56_ENV))
+#if defined(AFS_OSF20_ENV) && !defined(AFS_DUX50_ENV) || defined(AFS_AIX32_ENV) || (defined(AFS_SUN55_ENV) && !defined(AFS_SUN56_ENV)) || !defined(HAVE_SNPRINTF)
#include <sys/types.h>
#include <stdarg.h>
#include <stdio.h>
#include <ctype.h>
#include <netinet/in.h>
#include <netdb.h>
-#if defined(AFS_AIX32_ENV) || defined(AFS_SUN55_ENV)
+#if defined(AFS_AIX32_ENV) || defined(AFS_SUN_ENV)
#include <sys/socket.h>
#endif
* directory or online at http://www.openafs.org/dl/license10.html
*/
+/* String conversion routines have the following copyright */
+
+/*
+ * Copyright (c) 2002 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
#include <afsconfig.h>
#ifdef KERNEL
#include "../afs/param.h"
#include <afs/param.h>
#endif
-RCSID("$Header: /tmp/cvstemp/openafs/src/util/uuid.c,v 1.1.1.8 2002/08/02 04:37:25 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/util/uuid.c,v 1.1.1.9 2002/09/26 19:09:00 hartmans Exp $");
#ifdef KERNEL
#include "../afs/sysincludes.h"
* between user processes and Venus.
*/
#include <afs/param.h>
-#ifdef AFS_SUN5_ENV
+#ifdef AFS_SUN_ENV
#include <sys/ioccom.h>
#endif
#define _VICEIOCTL(id) ((unsigned int ) _IOW('V', id, struct ViceIoctl))
#define _VICEIOCTL2(dev, id) ((unsigned int ) _IOW(dev, id, struct ViceIoctl))
#endif
+#define _CVICEIOCTL(id) _VICEIOCTL2('C', id)
+#define _OVICEIOCTL(id) _VICEIOCTL2('O', id)
/* Use this macro to define up to 256 vice ioctl's. These ioctl's
all potentially have in/out parameters--this depends upon the
case ${SYS_NAME} in \
sun4_411 | sun4c_411 | sun4m_412 ) \
${CCXPG2} -g -I${TOP_SRCDIR}/config -I${TOP_INCDIR} -I${TOP_INCDIR} -c fstrace.c ;; \
+ sun*_4* ) \
+ ${CC} -I/usr/xpg2include -I/usr/5include -g -I${TOP_SRCDIR}/config -I${TOP_INCDIR} -I${TOP_INCDIR} -c fstrace.c ;; \
* ) \
${CC} ${CFLAGS} -g -I${TOP_SRCDIR}/config -I${TOP_INCDIR} -I${TOP_INCDIR} -c fstrace.c ;; \
esac
${CC} ${CFLAGS} -o fstrace fstrace.o ${TOP_LIBDIR}/libsys.a ${TOP_LIBDIR}/libcmd.a ${TOP_LIBDIR}/util.a /usr/lib/libi.a ;; \
sun4_411 | sun4c_411 | sun4m_412 ) \
${CCXPG2} ${CFLAGS} -g -o fstrace fstrace.o ${TOP_LIBDIR}/libsys.a ${TOP_LIBDIR}/libcmd.a ${TOP_LIBDIR}/util.a ;; \
+ sun*_4* ) \
+ ${CC} -L/usr/xpg2lib -L/usr/5lib ${CFLAGS} -g -o fstrace fstrace.o ${TOP_LIBDIR}/libsys.a ${TOP_LIBDIR}/libcmd.a ${TOP_LIBDIR}/util.a -lxpg ;; \
hp700_ux100 | hp800_ux100 | hp?00_ux10? | hp_ux10? | hp_ux11?) \
${CC} -I${TOP_SRCDIR}/config -o fstrace fstrace.o ${TOP_LIBDIR}/libsys.a ${TOP_LIBDIR}/libcmd.a ${TOP_LIBDIR}/util.a ;; \
* ) \
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/venus/fs.c,v 1.1.1.9 2002/01/22 19:54:57 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/venus/fs.c,v 1.1.1.10 2002/09/26 19:09:04 hartmans Exp $");
#include <afs/afs_args.h>
#include <rx/xdr.h>
* MAXCELLHOSTS (8) servers. To determine which we are talking to,
* do a GETCELL pioctl and pass it a magic number. If an array of
* 8 comes back, its a 3.5 client. If not, its a 3.4 client.
+ * If we get back EDOM, there are no cells in the kernel yet,
+ * and we'll assume a 3.5 client.
*/
tp = space;
lp = (afs_int32 *)tp;
blob.in = space;
blob.out = space;
code = pioctl(0, VIOCGETCELL, &blob, 1);
- if (code < 0) {
+ if (code < 0 && errno != EDOM) {
Die(errno, 0);
return 1;
}
- tp = space;
- cellname = tp + MAXCELLHOSTS*sizeof(afs_int32);
- scount = ((cellname[0] != '\0') ? MAXCELLHOSTS : MAXHOSTS);
+ if (code < 1 && errno == EDOM) {
+ scount = MAXHOSTS;
+ } else {
+ tp = space;
+ cellname = tp + MAXCELLHOSTS*sizeof(afs_int32);
+ scount = ((cellname[0] != '\0') ? MAXCELLHOSTS : MAXHOSTS);
+ }
/* Now setup and do the NEWCELL pioctl call */
memset(space, 0, (scount+1) * sizeof(afs_int32));
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/viced/callback.c,v 1.1.1.8 2002/05/11 00:03:26 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/viced/callback.c,v 1.1.1.9 2002/09/26 19:09:13 hartmans Exp $");
#include <stdio.h>
#include <stdlib.h> /* for malloc() */
} /*lih*/
-
/* This could be upgraded to get more space each time */
/* first pass: find the oldest host which isn't held by anyone */
/* second pass: find the oldest host who isn't "me" */
/* always called with hostp unlocked */
+extern struct host *hostList;
static int GetSomeSpace_r(hostp, locked)
struct host *hostp;
int locked;
{
- register struct host *hp, *hp1 = (struct host *)0;
+ register struct host *hp, *hp1 = (struct host *)0, *hp2 = hostList;
int i=0;
cbstuff.GotSomeSpaces++;
}
do {
lih_host = 0;
- h_Enumerate_r(lih_r, (char *)hp1);
+ h_Enumerate_r(lih_r, hp2, (char *)hp1);
hp = lih_host;
if (hp) {
cbstuff.GSS4++;
if ( ! ClearHostCallbacks_r(hp, 0 /* not locked or held */) )
return;
- hp1 = hp;
+ hp2 = hp->next;
} else {
+ hp2 = hostList;
hp1 = hostp;
cbstuff.GSS1++;
ViceLog(5,("GSS: Try harder for longest inactive host cnt= %d\n", i));
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/viced/fsprobe.c,v 1.1.1.5 2001/09/11 14:35:35 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/viced/fsprobe.c,v 1.1.1.6 2002/09/26 19:09:14 hartmans Exp $");
#include <afs/stds.h>
#include <afs/afsint.h>
memset((char *)&host, 0, sizeof(struct sockaddr_in));
host.sin_family = AF_INET;
host.sin_addr.s_addr = inet_addr(av[0]);
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ host.sin_len = sizeof(struct sockaddr_in);
+#endif
if (host.sin_addr.s_addr != -1) {
strcpy(hnamebuf, av[0]);
hostname = hnamebuf;
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/viced/host.c,v 1.1.1.10 2002/06/10 11:48:32 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/viced/host.c,v 1.1.1.11 2002/09/26 19:09:14 hartmans Exp $");
#include <stdio.h>
#include <errno.h>
free((void *)held);
} /*h_Enumerate*/
-/* h_Enumerate_r: Calls (*proc)(host, held, param) for at least each host in
- * the at the start of the enumeration (perhaps more). Hosts may be deleted
- * (have delete flag set); ditto for clients. (*proc) is always called with
+/* h_Enumerate_r (revised):
+ * Calls (*proc)(host, held, param) for each host in hostList, starting
+ * at enumstart
+ * Hosts may be deleted (have delete flag set); ditto for clients.
+ * (*proc) is always called with
* host h_held() and the global host lock (H_LOCK) locked.The hold state of the
* host with respect to this lwp is passed to (*proc) as the param held.
* The proc should return 0 if the host should be released, 1 if it should
* be held after enumeration.
*/
-h_Enumerate_r(proc, param)
+h_Enumerate_r(proc, enumstart, param)
int (*proc)();
+ struct host* enumstart;
char *param;
{
if (hostCount == 0) {
return;
}
- for (host = hostList ; host ; host = host->next) {
+ for (host = enumstart ; host ; host = host->next) {
if (!(held = h_Held_r(host)))
h_Hold_r(host);
held = (*proc)(host, held, param);
if (!held)
h_Release_r(host);/* this might free up the host */
}
-} /*h_Enumerate*/
-
+} /*h_Enumerate_r*/
/* Host is returned held */
struct host *h_GetHost_r(tcon)
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/viced/viced.c,v 1.1.1.8 2001/10/14 18:07:15 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/viced/viced.c,v 1.1.1.9 2002/09/26 19:09:16 hartmans Exp $");
#include <stdio.h>
#include <stdlib.h>
#include <sys/file.h>
#include <netinet/in.h>
#include <netdb.h>
-#include <sys/resource.h>
#include <unistd.h> /* sysconf() */
#ifndef ITIMER_REAL
#include <sys/time.h>
#endif /* ITIMER_REAL */
+#include <sys/resource.h>
#endif /* AFS_NT40_ENV */
#include <afs/stds.h>
#undef SHARED
rx_SetDestroyConnProc(tservice, (char (*)()) h_FreeConnection);
rx_SetMinProcs(tservice, 3);
rx_SetMaxProcs(tservice, lwps);
+ rx_SetCheckReach(tservice, 1);
tservice = rx_NewService(0, RX_STATS_SERVICE_ID, "rpcstats", sc, 4, RXSTATS_ExecuteRequest);
if (!tservice) {
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/vol/fssync.c,v 1.1.1.6 2002/08/02 04:37:35 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/vol/fssync.c,v 1.1.1.7 2002/09/26 19:09:21 hartmans Exp $");
#include <sys/types.h>
#include <stdio.h>
memset(addr, 0, sizeof(*addr));
assert((sd = socket(AF_INET, SOCK_STREAM, 0)) >= 0);
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ addr->sin_len = sizeof(struct sockaddr_in);
+#endif
addr->sin_addr.s_addr = htonl(0x7f000001);
addr->sin_family = AF_INET; /* was localhost->h_addrtype */
addr->sin_port = htons(2040); /* XXXX htons not _really_ neccessary */
+
return sd;
}
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/vol/listinodes.c,v 1.1.1.9 2001/10/14 18:07:22 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/vol/listinodes.c,v 1.1.1.10 2002/09/26 19:09:23 hartmans Exp $");
#ifndef AFS_NAMEI_ENV
-#ifdef AFS_LINUX20_ENV
+#if defined(AFS_LINUX20_ENV) || defined(AFS_SUN4_ENV)
/* ListViceInodes
*
* Return codes:
int (*judgeInode)();
int *forcep, forceR;
{
- Log("ListViceInodes not implemented for Linux\n");
+ Log("ListViceInodes not implemented for this platform!\n");
return -1;
}
#else
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/vol/namei_ops.c,v 1.1.1.7 2001/10/14 18:07:22 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/vol/namei_ops.c,v 1.1.1.8 2002/09/26 19:09:23 hartmans Exp $");
#ifdef AFS_NAMEI_ENV
#include <stdio.h>
*/
*cp = 0;
}
- if (!errno)
- closedir(ds);
+ /* if (!errno) -- closedir not implicit if we got an error */
+ closedir(ds);
}
/* finally axe the current dir */
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/vol/vol-salvage.c,v 1.1.1.10 2002/05/11 00:03:47 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/vol/vol-salvage.c,v 1.1.1.11 2002/09/26 19:09:26 hartmans Exp $");
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#endif /* ITIMER_REAL */
#endif
-#if defined(AFS_AIX_ENV)
+#if defined(AFS_AIX_ENV) || defined(AFS_SUN4_ENV)
#define WCOREDUMP(x) (x & 0200)
#endif
#include <rx/xdr.h>
#endif
#ifdef AFS_AIX42_ENV
+#ifndef AFS_NAMEI_ENV
/* We don't want to salvage big files filesystems, since we can't put volumes on
* them.
*/
return 0;
}
#endif
+#endif
#ifdef AFS_NT40_ENV
#define HDSTR "\\Device\\Harddisk"
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/vol/volume.c,v 1.1.1.11 2001/10/14 18:07:26 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/vol/volume.c,v 1.1.1.12 2002/09/26 19:09:28 hartmans Exp $");
#include <rx/xdr.h>
#include <afs/afsint.h>
#endif /* AFS_PTHREAD_ENV */
#include "vutils.h"
#include "fssync.h"
-#if !defined(AFS_NT40_ENV) && !defined(AFS_NAMEI_ENV)
-#include <afs/osi_inode.h>
-#endif
#ifndef AFS_NT40_ENV
#include <unistd.h>
#endif
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/volser/vos.c,v 1.1.1.10 2002/08/02 04:37:52 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/volser/vos.c,v 1.1.1.11 2002/09/26 19:09:35 hartmans Exp $");
#include <sys/types.h>
#ifdef AFS_NT40_ENV
printuuid=1;
}
+ m_addrs.bulkaddrs_val = 0;
+ m_addrs.bulkaddrs_len = 0;
+
+ vcode = ubik_Call_New(VL_GetAddrs, cstruct, 0,
+ 0, 0, &m_unique, &nentries, &m_addrs);
+ if (vcode) {
+ fprintf(STDERR,"vos: could not list the server addresses\n");
+ PrintError("",vcode);
+ return( vcode );
+ }
+
m_nentries = 0;
m_addrs.bulkaddrs_val = 0;
m_addrs.bulkaddrs_len = 0;
vcode = ubik_Call_New(VL_GetAddrsU, cstruct, 0, &m_attrs, &m_uuid,
&m_unique, &m_nentries, &m_addrs);
- if(vcode == VL_NOENT)
- break;
+ if(vcode == VL_NOENT) {
+ i++;
+ nentries++;
+ continue;
+ }
if (vcode) {
fprintf(STDERR,"vos: could not list the server addresses\n");
print_addrs(&m_addrs, &m_uuid, m_nentries, printuuid, noresolve);
i++;
- if ((as->parms[1].items)||(as->parms[0].items))
+ if ((as->parms[1].items)||(as->parms[0].items)||(i>nentries))
break;
}
#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header: /tmp/cvstemp/openafs/src/volser/vsprocs.c,v 1.1.1.8 2001/10/14 18:07:32 hartmans Exp $");
+RCSID("$Header: /tmp/cvstemp/openafs/src/volser/vsprocs.c,v 1.1.1.9 2002/09/26 19:09:36 hartmans Exp $");
#include <stdio.h>
#include <sys/types.h>
if (entry.serverFlags[j] & ITSROVOL) {
/* Verify this volume exists and print message we are orphaning it */
if (pass == 1) {
- MapPartIdIntoName(apart, entry.serverPartition[j]);
+ MapPartIdIntoName(apart, pname);
fprintf(STDERR,"*** Warning: Orphaned RO volume %u exists on %s %s\n",
entry.volumeId[ROVOL],
hostutil_GetNameByINet(entry.serverNumber[j]), pname);
if (modified && (code == VL_NOENT)) {
fprintf(STDOUT,"\n**entry deleted**\n");
} else if (modified) {
- EnumerateEntry(vldbentry);
+ EnumerateEntry(&vldbentry);
} else {
fprintf(STDOUT,"\n**no change**\n");
}
projects / packages / o / openafs.git / commitdiff