we'll finish it on a branch and remerge; 1.3.83 needs to happen and 1.4 needs to go out.
====================
This delta was composed from multiple commits as part of the CVS->Git migration.
The checkin message with each commit was inconsistent.
The following are the additional commit messages.
====================
we'll finish it on a branch and remerge; 1.3.83 needs to happen and 1.4 needs to
go out.
#endif
#endif
-#ifdef AFS_DARWIN80_ENV
-#include <kern/locks.h>
-#else
#include <sys/lock.h>
-#include <sys/user.h>
-#endif
#include <kern/thread.h>
+#include <sys/user.h>
-#ifdef AFS_DARWIN80_ENV
-#define getpid() proc_selfpid()
-#define getppid() proc_selfppid()
-#else
#define getpid() current_proc()->p_pid
#define getppid() current_proc()->p_pptr->p_pid
-#endif
#undef gop_lookupname
#define gop_lookupname osi_lookupname
/* vcexcl - used only by afs_create */
enum vcexcl { EXCL, NONEXCL };
-#ifndef AFS_DARWIN80_ENV
-#define ifaddr_address_family(x) (x)->ifa_addr->sa_family
-#define ifaddr_address(x, y, z) memcpy(y, (x)->ifa_addr, z)
-#define ifaddr_netmask(x, y, z) memcpy(y, (x)->ifa_netmask, z)
-#define ifaddr_dstaddress(x, y, z) memcpy(y, (x)->ifa_dstaddr, z)
-#define ifaddr_ifnet(x) (x?(x)->ifa_ifp:0)
-#define ifnet_flags(x) (x?(x)->if_flags:0)
-#define ifnet_metric(x) (x?(x)->if_data.ifi_metric:0)
-#endif
-
-#ifndef AFS_DARWIN80_ENV
-#define ifaddr_address_family(x) (x)->ifa_addr->sa_family
-#define ifaddr_address(x, y, z) memcpy(y, (x)->ifa_addr, z)
-#define ifaddr_netmask(x, y, z) memcpy(y, (x)->ifa_netmask, z)
-#define ifaddr_dstaddress(x, y, z) memcpy(y, (x)->ifa_dstaddr, z)
-#define ifaddr_ifnet(x) (x?(x)->ifa_ifp:0)
-#define ifnet_flags(x) (x?(x)->if_flags:0)
-#define ifnet_metric(x) (x?(x)->if_data.ifi_metric:0)
-
-#define vnode_clearfsnode(x) ((x)->v_data = 0)
-#define vnode_fsnode(x) (x)->v_data
-#define vnode_lock(x) vn_lock(x, LK_EXCLUSIVE | LK_RETRY, current_proc());
-#define vnode_isvroot(x) (((x)->v_flag & VROOT)?1:0)
-#endif
-
-#ifdef AFS_DARWIN80_ENV
-#define vrele vnode_rele
-#define vput vnode_put
-#define vref vnode_ref
-#define vattr vnode_attr
-
-#define va_size va_data_size
-#define va_atime va_access_time
-#define va_mtime va_modify_time
-#define va_ctime va_change_time
-#define va_bytes va_total_alloc
-#define va_blocksize va_iosize
-#define va_nodeid va_fileid
-
-#define SetAfsVnode(vn) /* nothing; done in getnewvnode() */
-/* vnode_vfsfsprivate is not declared, so no macro for us */
-extern void * afs_fsprivate_data;
-static inline int IsAfsVnode(vnode_t vn) {
- mount_t mp;
- int res = 0;
- mp = vnode_mount(vn);
- if (mp) {
- res = (vfs_fsprivate(mp) == &afs_fsprivate_data);
- vfs_mountrelease(mp);
- }
- return res;
-}
-#endif
-
/*
* Time related macros
*/
#ifndef AFS_DARWIN60_ENV
extern struct timeval time;
#endif
-#ifdef AFS_DARWIN80_ENV
-static inline time_t osi_Time(void) {
- struct timeval _now;
- microtime(&_now);
- return _now.tv_sec;
-}
-#else
#define osi_Time() (time.tv_sec)
-#endif
#define afs_hz hz
#define PAGESIZE 8192
#ifdef KERNEL
extern thread_t afs_global_owner;
/* simple locks cannot be used since sleep can happen at any time */
-#ifdef AFS_DARWIN80_ENV
-/* mach locks still don't have an exported try, but we are forced to use them */
-extern lck_mtx_t *afs_global_lock;
-#define AFS_GLOCK() \
- do { \
- lk_mtx_lock(afs_global_lock); \
- osi_Assert(afs_global_owner == 0); \
- afs_global_owner = current_thread(); \
- } while (0)
-#define AFS_GUNLOCK() \
- do { \
- osi_Assert(afs_global_owner == current_thread()); \
- afs_global_owner = 0; \
- lk_mtx_unlock(afs_global_lock); \
- } while(0)
-#else
/* Should probably use mach locks rather than bsd locks, since we use the
mach thread control api's elsewhere (mach locks not used for consistency
with rx, since rx needs lock_write_try() in order to use mach locks
afs_global_owner = 0; \
lockmgr(&afs_global_lock, LK_RELEASE, 0, current_proc()); \
} while(0)
-#endif
#define ISAFS_GLOCK() (afs_global_owner == current_thread())
#define SPLVAR
#define AFS_APPL_UFS_CACHE 1
#define AFS_APPL_HFS_CACHE 2
-extern ino_t VnodeToIno(struct vnode * vp);
-extern dev_t VnodeToDev(struct vnode * vp);
+extern ino_t VnodeToIno(vnode_t * vp);
+extern dev_t VnodeToDev(vnode_t * vp);
#define osi_curproc() current_proc()
/* FIXME */
#define osi_curcred() &afs_osi_cred
-#ifdef AFS_DARWIN80_ENV
-uio_t afsio_darwin_partialcopy(uio_t auio, int size);
-#endif
-
#endif /* KERNEL */
#endif /* _OSI_MACHDEP_H_ */
#include "afsincludes.h"
#include <sys/namei.h>
-#ifdef AFS_DARWIN80_ENV
-int
-osi_lookupname(char *aname, enum uio_seg seg, int followlink,
- struct vnode **vpp) {
- vfs_context_t ctx;
- char tname[PATHBUFLEN];
- int len, code, flags;
-
- if (seg == AFS_UIOUSER) { /* XXX 64bit */
- AFS_COPYINSTR(aname, tname, PATHBUFLEN, code);
- if (code)
- return code;
- aname=tname;
- }
- flags = 0
- if (!followlink)
- flag |= VNODE_LOOKUP_NOFOLLOW;
- ctx=vfs_context_create(NULL);
- code = vnode_lookup(aname, flags, vpp, ctx);
- vfs_context_rele(ctx);
- return code;
-}
-#else
int
osi_lookupname(char *aname, enum uio_seg seg, int followlink,
struct vnode **vpp)
VOP_UNLOCK(n.ni_vp, 0, current_proc());
return 0;
}
-#endif
/*
* afs_suser() returns true if the caller is superuser, false otherwise.
*
* Note that it must NOT set errno.
*/
-int
+
afs_suser(void *credp)
{
int error;
struct proc *p = current_proc();
-#if AFS_DARWIN80_ENV
- return proc_suser(p);
-#else
if ((error = suser(p->p_ucred, &p->p_acflag)) == 0) {
return (1);
}
return (0);
-#endif
-}
-
-#ifdef AFS_DARWIN80_ENV
-uio_t afsio_darwin_partialcopy(uio_t auio, int size) {
- uio_t res;
- int index;
- user_addr_t iovaddr;
- user_size_r iovsize;
-
- /* XXX 64 bit userspaace? */
- res = uio_create(uio_iovcnt(auio), uio_offset(auio),
- uio_isuserspace(auio) ? UIO_USERSPACE32 : UIO_SYSSPACE32,
- uio_rw(auio));
-
- for (i = 0;i < uio_iovcnt(auio) && size > 0;i++) {
- if (uio_getiov(auio, index, &iovaddr, &iovsize))
- break;
- if (iovsize > size)
- iovsize = size;
- if (uio_addiov(res, iovaddr, iovsize))
- break;
- size -= iovsize;
- }
- return res;
}
-#endif
sysent[AFS_SYSCALL].sy_parallel = 0;
#ifdef KERNEL_FUNNEL
sysent[AFS_SYSCALL].sy_funnel = KERNEL_FUNNEL;
-#endif
-#ifdef AFS_DARWIN80_ENV
- MUTEX_SETUP();
- afs_global_lock = lck_mtx_alloc(openafs_lck_grp, 0);
#endif
return KERN_SUCCESS;
}
/* give up the stolen syscall entry */
sysent[AFS_SYSCALL].sy_narg = 0;
sysent[AFS_SYSCALL].sy_call = nosys;
-#ifdef AFS_DARWIN80_ENV
- MUTEX_FINISH();
- lck_mtx_free(afs_global_lock);
-#endif
return KERN_SUCCESS;
}
if (flags & MNT_FORCE) {
if (afs_globalVp) {
AFS_GUNLOCK();
-#ifdef AFS_DARWIN80_ENV
- vnode_rele(AFSTOV(afs_globalVp));
-#else
vrele(AFSTOV(afs_globalVp));
-#endif
AFS_GLOCK();
}
afs_globalVp = NULL;
vprint("bad usecount", vp);
panic("afs_vget");
}
-#ifdef AFS_DARWIN80_ENV
- error = vnode_get(vp);
-#else
error = vget(vp, lfl, current_proc());
-#endif
if (!error)
insmntque(vp, mp); /* take off free list */
return error;
ourselves during vop_inactive, except we also need to not reinst
the ubc... so we just call VREF there now anyway. */
- if (VREFCOUNT_GT(tvc, 0))
-#ifdef AFS_DARWIN80_ENV
- vnode_ref(vp);
-#else
+ if (VREFCOUNT(tvc) > 0)
VREF(((struct vnode *)(vp)));
-#endif
else
-#ifdef AFS_DARWIN80_ENV
- vnode_get(vp);
-#else
afs_vget(afs_globalVFS, 0, (vp));
-#endif
if (UBCINFOMISSING(vp) || UBCINFORECLAIMED(vp)) {
ubc_info_init(vp);
{
struct vm_object *obj;
struct vnode *vp;
- if (VREFCOUNT_GT(avc, 1))
+ if (VREFCOUNT(avc) > 1)
return EBUSY;
if (avc->opens)
#define AFS_PROC struct proc
#define AFS_UCRED ucred
#define afs_suser(x) afs_osi_suser(osi_curcred())
-#define getpid() (curproc->p_pid)
+#define getpid() curproc
#define osi_curcred() (curproc->p_cred->pc_ucred)
#define osi_curproc() curproc
#define p_rcred p_ucred
#define AfsLargeFileSize(pos, off) ( ((offset_t)(pos)+(offset_t)(off) > (offset_t)0x7fffffff)?1:0)
#endif
-/* for afs/VNOPS/afs_vnop_attrs.c */
-#define va_blocks va_nblocks
#endif /* _OSI_MACHDEP_H_ */
attrs->va_fsid = avc->v.v_vfsp->vfs_fsid.val[0];
#elif defined(AFS_OSF_ENV)
attrs->va_fsid = avc->v.v_mount->m_stat.f_fsid.val[0];
-#elif defined(AFS_DARWIN80_ENV)
- VATTR_RETURN(attrs, va_fsid, vfs_statfs(vnode_mount(AFSTOV(avc)))->f_fsid.val[0]);
#elif defined(AFS_DARWIN70_ENV)
attrs->va_fsid = avc->v->v_mount->mnt_stat.f_fsid.val[0];
#else /* ! AFS_DARWIN70_ENV */
* Below return 0 (and not 1) blocks if the file is zero length. This conforms
* better with the other filesystems that do return 0.
*/
-#ifdef AFS_HPUX_ENV
- attrs->va_blocks = (attrs->va_size ? ((attrs->va_size + 1023) >> 10) : 0);
+#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
+#if !defined(AFS_HPUX_ENV)
+#ifdef AFS_SUN5_ENV
+ attrs->va_nblocks =
+ (attrs->va_size ? ((attrs->va_size + 1023) >> 10) << 1 : 0);
#elif defined(AFS_SGI_ENV)
attrs->va_blocks = BTOBB(attrs->va_size);
-#elif defined(AFS_XBSD_ENV) || defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV)
- attrs->va_bytes = (attrs->va_size ? (attrs->va_size + 1023) : 1024);
-#ifdef va_bytes_rsv
- attrs->va_bytes_rsv = -1;
-#endif
#else
attrs->va_blocks =
(attrs->va_size ? ((attrs->va_size + 1023) >> 10) << 1 : 0);
#endif
+#else /* !defined(AFS_HPUX_ENV) */
+ attrs->va_blocks = (attrs->va_size ? ((attrs->va_size + 1023) >> 10) : 0);
+#endif /* !defined(AFS_HPUX_ENV) */
+#else /* ! AFS_OSF_ENV && !AFS_DARWIN_ENV && !AFS_XBSD_ENV */
+ attrs->va_bytes = (attrs->va_size ? (attrs->va_size + 1023) : 1024);
+#ifdef va_bytes_rsv
+ attrs->va_bytes_rsv = -1;
+#endif
+#endif /* ! AFS_OSF_ENV && !AFS_DARWIN_ENV && !AFS_XBSD_ENV */
#ifdef AFS_LINUX22_ENV
/* And linux has its own stash as well. */
attrs->va_nodeid = ip->i_ino;
}
#else
- if (vnode_isvroot(AFSTOV(avc))) {
+ if (AFSTOV(avc)->v_flag & VROOT) {
struct vnode *vp = AFSTOV(avc);
-#ifdef AFS_DARWIN80_ENV
- /* XXX vp = vnode_mount(vp)->mnt_vnodecovered; */
- vp = 0;
-#else
vp = vp->v_vfsp->vfs_vnodecovered;
if (vp) { /* Ignore weird failures */
#ifdef AFS_SGI62_ENV
attrs->va_nodeid = ip->i_number;
#endif
}
-#endif
}
#endif /* AFS_LINUX22_ENV */
}
*avcp = tvc;
code = (tvc ? 0 : ENOENT);
hit = 1;
- if (tvc && !VREFCOUNT_GT(tvc, 0)) {
+ if (tvc && !VREFCOUNT(tvc)) {
osi_Panic("TT1");
}
if (code) {
code = 0;
*avcp = tvc = adp;
hit = 1;
- if (adp && !VREFCOUNT_GT(adp, 0)) {
+ if (adp && !VREFCOUNT(adp)) {
osi_Panic("TT2");
}
goto done;
}
}
*avcp = tvc;
- if (tvc && !VREFCOUNT_GT(tvc, 0)) {
+ if (tvc && !VREFCOUNT(tvc)) {
osi_Panic("TT3");
}
code = 0;
afs_int32 trimlen;
struct dcache *tdc = 0;
afs_int32 error, trybusy = 1;
-#ifdef AFS_DARWIN80_ENV
- uio_t tuiop;
-#else
struct uio tuio;
- struct uio *tuiop = &tuio;
struct iovec *tvec;
-#endif
afs_int32 code;
struct vrequest treq;
}
#endif
-#ifndef AFS_DARWIN80_ENV
tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));
-#endif
- totalLength = AFS_UIO_RESID(auio);
- filePos = AFS_UIO_OFFSET(auio);
+ totalLength = auio->afsio_resid;
+ filePos = auio->afsio_offset;
afs_Trace4(afs_iclSetp, CM_TRACE_READ, ICL_TYPE_POINTER, avc,
ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(filePos), ICL_TYPE_INT32,
totalLength, ICL_TYPE_OFFSET,
len = tlen;
if (len > AFS_ZEROS)
len = sizeof(afs_zeros); /* and in 0 buffer */
-#ifdef AFS_DARWIN80_ENV
- trimlen = len;
- tuiop = afsio_darwin_partialcopy(auio, trimlen);
-#else
afsio_copy(auio, &tuio, tvec);
trimlen = len;
afsio_trim(&tuio, trimlen);
-#endif
- AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, tuiop, code);
+ AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, &tuio, code);
if (code) {
error = code;
break;
/* get the data from the mem cache */
/* mung uio structure to be right for this transfer */
-#ifdef AFS_DARWIN80_ENV
- trimlen = len;
- tuiop = afsio_darwin_partialcopy(auio, trimlen);
- uio_setoffset(tuiop, offset);
-#else
afsio_copy(auio, &tuio, tvec);
trimlen = len;
afsio_trim(&tuio, trimlen);
tuio.afsio_offset = offset;
-#endif
- code = afs_MemReadUIO(tdc->f.inode, tuiop);
+ code = afs_MemReadUIO(tdc->f.inode, &tuio);
if (code) {
error = code;
}
}
/* otherwise we've read some, fixup length, etc and continue with next seg */
- len = len - AFS_UIO_RESID(tuiop); /* compute amount really transferred */
+ len = len - tuio.afsio_resid; /* compute amount really transferred */
trimlen = len;
afsio_skip(auio, trimlen); /* update input uio structure */
totalLength -= len;
}
if (!noLock)
ReleaseReadLock(&avc->lock);
-#ifdef AFS_DARWIN80_ENV
- uio_free(tuiop);
-#else
osi_FreeSmallSpace(tvec);
-#endif
error = afs_CheckCode(error, &treq, 10);
return error;
}
afs_int32 trimlen;
struct dcache *tdc = 0;
afs_int32 error;
-#ifdef AFS_DARWIN80_ENV
- uio_t tuiop;
-#else
struct uio tuio;
- struct uio *tuiop = &tuio;
struct iovec *tvec;
-#endif
struct osi_file *tfile;
afs_int32 code;
int trybusy = 1;
}
#endif
-#ifndef AFS_DARWIN80_ENV
tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));
-#endif
- totalLength = AFS_UIO_RESID(auio);
- filePos = AFS_UIO_OFFSET(auio);
+ totalLength = auio->afsio_resid;
+ filePos = auio->afsio_offset;
afs_Trace4(afs_iclSetp, CM_TRACE_READ, ICL_TYPE_POINTER, avc,
ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(filePos), ICL_TYPE_INT32,
totalLength, ICL_TYPE_OFFSET,
len = tlen;
if (len > AFS_ZEROS)
len = sizeof(afs_zeros); /* and in 0 buffer */
-#ifdef AFS_DARWIN80_ENV
- trimlen = len;
- tuiop = afsio_darwin_partialcopy(auio, trimlen);
-#else
afsio_copy(auio, &tuio, tvec);
trimlen = len;
afsio_trim(&tuio, trimlen);
-#endif
- AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, tuiop, code);
+ AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, &tuio, code);
if (code) {
error = code;
break;
#endif /* IHINT */
tfile = (struct osi_file *)osi_UFSOpen(tdc->f.inode);
-#ifdef AFS_DARWIN80_ENV
- trimlen = len;
- tuiop = afsio_darwin_partialcopy(auio, trimlen);
- uio_setoffset(tuiop, offset);
-#else
/* mung uio structure to be right for this transfer */
afsio_copy(auio, &tuio, tvec);
trimlen = len;
afsio_trim(&tuio, trimlen);
tuio.afsio_offset = offset;
-#endif
-
#if defined(AFS_AIX41_ENV)
AFS_GUNLOCK();
code =
code = VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp);
VOP_UNLOCK(tfile->vnode, 0, current_proc());
AFS_GLOCK();
-#elif defined(AFS_DARWIN80_ENV)
- AFS_GUNLOCK();
- code = VOP_READ(tfile->vnode, tuiop, 0, afs_osi_ctxp);
- AFS_GLOCK();
-#elif defined(AFS_DARWIN_ENV)
- AFS_GUNLOCK();
- VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
- code = VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp);
- VOP_UNLOCK(tfile->vnode, 0, current_proc());
- AFS_GLOCK();
#elif defined(AFS_FBSD50_ENV)
AFS_GUNLOCK();
VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curthread);
}
}
/* otherwise we've read some, fixup length, etc and continue with next seg */
- len = len - AFS_UIO_RESID(tuiop); /* compute amount really transferred */
+ len = len - tuio.afsio_resid; /* compute amount really transferred */
trimlen = len;
afsio_skip(auio, trimlen); /* update input uio structure */
totalLength -= len;
if (!noLock)
ReleaseReadLock(&avc->lock);
-#ifdef AFS_DARWIN80_ENV
- uio_free(tuiop);
-#else
osi_FreeSmallSpace(tvec);
-#endif
error = afs_CheckCode(error, &treq, 13);
return error;
}
afs_symhint_inval(tvc);
Tadp1 = adp;
-#ifndef AFS_DARWIN80_ENV
Tadpr = VREFCOUNT(adp);
-#endif
Ttvc = tvc;
Tnam = aname;
Tnam1 = 0;
if (tvc)
-#ifndef AFS_DARWIN80_ENV
Ttvcr = VREFCOUNT(tvc);
-#endif
#ifdef AFS_AIX_ENV
- if (tvc && VREFCOUNT_GT(tvc, 2) && tvc->opens > 0
- && !(tvc->states & CUnlinked)) {
+ if (tvc && (VREFCOUNT(tvc) > 2) && tvc->opens > 0
+ && !(tvc->states & CUnlinked))
#else
- if (tvc && VREFCOUNT_GT(tvc, 1) && tvc->opens > 0
- && !(tvc->states & CUnlinked)) {
+ if (tvc && (VREFCOUNT(tvc) > 1) && tvc->opens > 0
+ && !(tvc->states & CUnlinked))
#endif
+ {
char *unlname = afs_newname();
ReleaseWriteLock(&adp->lock);
volatile
#endif
afs_int32 error;
-#ifdef AFS_DARWIN80_ENV
- uio_t tuiop;
-#else
struct uio tuio;
- struct uio *tuiop = &tuio;
struct iovec *tvec; /* again, should have define */
-#endif
register afs_int32 code;
struct vrequest treq;
* as will fit */
len = max - offset;
}
-
-#ifdef AFS_DARWIN80_ENV
- trimlen = len;
- tuiop = afsio_darwin_partialcopy(auio, trimlen);
- uio_setoffset(tuiop, offset);
-#else
/* mung uio structure to be right for this transfer */
afsio_copy(auio, &tuio, tvec);
trimlen = len;
afsio_trim(&tuio, trimlen);
tuio.afsio_offset = offset;
-#endif
- code = afs_MemWriteUIO(tdc->f.inode, tuiop);
+ code = afs_MemWriteUIO(tdc->f.inode, &tuio);
if (code) {
void *mep; /* XXX in prototype world is struct memCacheEntry * */
error = code;
break;
}
/* otherwise we've written some, fixup length, etc and continue with next seg */
- len = len - AFS_UIO_RESID(tuiop); /* compute amount really transferred */
+ len = len - tuio.afsio_resid; /* compute amount really transferred */
tlen = len;
afsio_skip(auio, tlen); /* advance auio over data written */
/* compute new file size */
avc->vc_error = error;
if (!noLock)
ReleaseWriteLock(&avc->lock);
-#ifdef AFS_DARWIN80_ENV
- uio_free(tuiop);
-#else
osi_FreeSmallSpace(tvec);
-#endif
error = afs_CheckCode(error, &treq, 6);
return error;
}
volatile
#endif
afs_int32 error;
-#ifdef AFS_DARWIN80_ENV
- uio_t tuiop;
-#else
struct uio tuio;
- struct uio *tuiop = &tuio;
struct iovec *tvec; /* again, should have define */
-#endif
struct osi_file *tfile;
register afs_int32 code;
struct vrequest treq;
#if defined(AFS_SUN56_ENV)
auio->uio_loffset = 0;
#endif
- filePos = avc->m.Length;
-#ifdef AFS_DARWIN80_ENV
- uio_setoffset(auio, avc->m.Length);
-#else
- auio->afsio_offset = avc->m.Length;
-#endif
+ filePos = auio->afsio_offset = avc->m.Length;
}
#endif
/*
afs_FakeOpen(avc);
#endif
avc->states |= CDirty;
-#ifndef AFS_DARWIN80_ENV
tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));
-#endif
while (totalLength > 0) {
/*
* The following line is necessary because afs_GetDCache with
* as will fit */
len = max - offset;
}
-
-#ifdef AFS_DARWIN80_ENV
- trimlen = len;
- tuiop = afsio_darwin_partialcopy(auio, trimlen);
- uio_setoffset(tuiop, offset);
-#else
/* mung uio structure to be right for this transfer */
afsio_copy(auio, &tuio, tvec);
trimlen = len;
afsio_trim(&tuio, trimlen);
tuio.afsio_offset = offset;
-#endif
-
#if defined(AFS_AIX41_ENV)
AFS_GUNLOCK();
code =
AFS_GUNLOCK();
code = osi_rdwr(tfile, &tuio, UIO_WRITE);
AFS_GLOCK();
-#elif defined(AFS_DARWIN80_ENV)
- AFS_GUNLOCK();
- code = VOP_WRITE(tfile->vnode, tuiop, 0, afs_osi_ctxtp);
- AFS_GLOCK();
#elif defined(AFS_DARWIN_ENV)
AFS_GUNLOCK();
VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
break;
}
/* otherwise we've written some, fixup length, etc and continue with next seg */
- len = len - AFS_UIO_RESID(tuiop); /* compute amount really transferred */
+ len = len - tuio.afsio_resid; /* compute amount really transferred */
tlen = len;
afsio_skip(auio, tlen); /* advance auio over data written */
/* compute new file size */
avc->vc_error = error;
if (!noLock)
ReleaseWriteLock(&avc->lock);
-#ifdef AFS_DARWIN80_ENV
- uio_free(tuiop);
-#else
osi_FreeSmallSpace(tvec);
-#endif
#ifndef AFS_VM_RDWR_ENV
/*
* If write is implemented via VM, afs_fsync() is called from the high-level
#define vrefCount v.v_count
#endif /* AFS_XBSD_ENV */
-#if defined(AFS_DARWIN80_ENV)
-#define VREFCOUNT_GT(v, y) vnode_isinuse(AFSTOV(v), (y))
-#elif defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV)
-#define VREFCOUNT(v) ((v)->vrefCount)
-#define VREFCOUNT_GT(v, y) (AFSTOV(v)->v_usecount > (y))
-#elif defined(AFS_LINUX24_ENV)
+#if defined(AFS_LINUX24_ENV)
#define VREFCOUNT(v) atomic_read(&((vnode_t *) v)->v_count)
-#define VREFCOUNT_GT(v, y) ((atomic_read(&((vnode_t *) v)->v_count)>y)?1:0)
#define VREFCOUNT_SET(v, c) atomic_set(&((vnode_t *) v)->v_count, c)
#define VREFCOUNT_DEC(v) atomic_dec(&((vnode_t *) v)->v_count)
#define VREFCOUNT_INC(v) atomic_inc(&((vnode_t *) v)->v_count)
#else
#define VREFCOUNT(v) ((v)->vrefCount)
-#define VREFCOUNT_GT(v,y) ((v)->vrefCount > (y))
#define VREFCOUNT_SET(v, c) (v)->vrefCount = c;
#define VREFCOUNT_DEC(v) (v)->vrefCount--;
#define VREFCOUNT_INC(v) (v)->vrefCount++;
extern afs_uint32 afs_stampValue; /* stamp for pair's usage */
#define MakeStamp() (++afs_stampValue)
-#if defined(AFS_DARWIN_ENV)
-#define VTOAFS(v) ((struct vcache *)vnode_fsnode((v)))
-#define AFSTOV(vc) ((vc)->v)
-#elif defined(AFS_XBSD_ENV)
+#if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV)
#define VTOAFS(v) ((struct vcache *)(v)->v_data)
#define AFSTOV(vc) ((vc)->v)
#else
int ownslock; /* pid of owner of excl lock, else 0 - defect 3083 */
#endif
#ifdef AFS_DARWIN_ENV
-#ifdef AFS_DARWIN80_ENV
- lck_mtx_t *rwlock;
-#else
struct lock__bsd__ rwlock;
#endif
-#endif
#ifdef AFS_XBSD_ENV
struct lock rwlock;
#endif
a_result->DataVersion = hgetlo(tvc->m.DataVersion);
a_result->callback = afs_data_pointer_to_int32(tvc->callback); /* XXXX Now a pointer; change it XXXX */
a_result->cbExpires = tvc->cbExpires;
-#ifdef AFS_DARWIN80_ENV
- a_result->refCount = vnode_isinuse(AFSTOV(tvc),0)?1:0; /* XXX fix */
-#else
a_result->refCount = VREFCOUNT(tvc);
-#endif
a_result->opens = tvc->opens;
a_result->writers = tvc->execsOrWriters;
a_result->mvstat = tvc->mvstat;
a_result->DataVersion = hgetlo(tvc->m.DataVersion);
a_result->callback = afs_data_pointer_to_int32(tvc->callback); /* XXXX Now a pointer; change it XXXX */
a_result->cbExpires = tvc->cbExpires;
-#ifdef AFS_DARWIN80_ENV
- a_result->refCount = vnode_isinuse(AFSTOV(tvc),0)?1:0; /* XXX fix */
-#else
a_result->refCount = VREFCOUNT(tvc);
-#endif
a_result->opens = tvc->opens;
a_result->writers = tvc->execsOrWriters;
a_result->mvstat = tvc->mvstat;
VFS_STATFS(filevp->v_vfsp, &st);
TO_KERNEL_SPACE();
}
-#elif defined(AFS_DARWIN80_ENV)
- afs_cacheVfsp = vnode_mount(filevp);
- if (afs_cacheVfsp && !VFS_STATFS(afs_cacheVfsp, &st, current_proc()))
#elif defined(AFS_DARWIN_ENV)
if (!VFS_STATFS(filevp->v_mount, &st, current_proc()))
#elif defined(AFS_FBSD50_ENV)
#endif
cacheInode = afs_vnodeToInumber(filevp);
cacheDev.dev = afs_vnodeToDev(filevp);
-#ifndef AFS_DARWIN80_ENV
afs_cacheVfsp = filevp->v_vfsp;
-#endif
#endif /* AFS_LINUX20_ENV */
AFS_RELE(filevp);
#endif /* AFS_LINUX22_ENV */
{
register struct memCacheEntry *mceP =
(struct memCacheEntry *)afs_MemCacheOpen(blkno);
- int length = mceP->size - AFS_UIO_OFFSET(uioP);
+ int length = mceP->size - uioP->uio_offset;
afs_int32 code;
AFS_STATCNT(afs_MemReadUIO);
MObtainReadLock(&mceP->afs_memLock);
- length = (length < AFS_UIO_RESID(uioP)) ? length : AFS_UIO_RESID(uioP);
- AFS_UIOMOVE(mceP->data + AFS_UIO_OFFSET(uioP), length, UIO_READ, uioP, code);
+ length = (length < uioP->uio_resid) ? length : uioP->uio_resid;
+ AFS_UIOMOVE(mceP->data + uioP->uio_offset, length, UIO_READ, uioP, code);
MReleaseReadLock(&mceP->afs_memLock);
return code;
}
AFS_STATCNT(afs_MemWriteUIO);
MObtainWriteLock(&mceP->afs_memLock, 312);
- if (AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP) > mceP->dataSize) {
+ if (uioP->uio_resid + uioP->uio_offset > mceP->dataSize) {
char *oldData = mceP->data;
- mceP->data = afs_osi_Alloc(AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP));
+ mceP->data = afs_osi_Alloc(uioP->uio_resid + uioP->uio_offset);
AFS_GUNLOCK();
memcpy(mceP->data, oldData, mceP->size);
AFS_GLOCK();
afs_osi_Free(oldData, mceP->dataSize);
- mceP->dataSize = AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP);
+ mceP->dataSize = uioP->uio_resid + uioP->uio_offset;
}
- if (mceP->size < AFS_UIO_OFFSET(uioP))
+ if (mceP->size < uioP->uio_offset)
memset(mceP->data + mceP->size, 0,
- (int)(AFS_UIO_OFFSET(uioP) - mceP->size));
- AFS_UIOMOVE(mceP->data + AFS_UIO_OFFSET(uioP), AFS_UIO_RESID(uioP), UIO_WRITE,
+ (int)(uioP->uio_offset - mceP->size));
+ AFS_UIOMOVE(mceP->data + uioP->uio_offset, uioP->uio_resid, UIO_WRITE,
uioP, code);
- if (AFS_UIO_OFFSET(uioP) > mceP->size)
- mceP->size = AFS_UIO_OFFSET(uioP);
+ if (uioP->uio_offset > mceP->size)
+ mceP->size = uioP->uio_offset;
MReleaseWriteLock(&mceP->afs_memLock);
return code;
#elif defined(AFS_FBSD50_ENV)
mtx_init(&afs_global_mtx, "AFS global lock", NULL, MTX_DEF);
#elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
-#if !defined(AFS_DARWIN80_ENV)
lockinit(&afs_global_lock, PLOCK, "afs global lock", 0, 0);
-#endif
afs_global_owner = 0;
#elif defined(AFS_AIX41_ENV)
lock_alloc((void *)&afs_global_lock, LOCK_ALLOC_PIN, 1, 1);
curproc->p_flag |= SSYS;
#elif defined(AFS_HPUX101_ENV) && !defined(AFS_HPUX1123_ENV)
set_system_proc(u.u_procp);
-#elif defined(AFS_DARWIN80_ENV)
#elif defined(AFS_DARWIN_ENV)
/* maybe call init_process instead? */
current_proc()->p_flag |= P_SYSTEM;
}
#endif
-#if (defined(AFS_DARWIN_ENV) && !defined(AFS_DARWIN80_ENV)) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
void
afs_osi_TraverseProcTable(void)
{
return rv;
}
-#elif defined(AFS_DARWIN80_ENV)
-const struct AFS_UCRED *
-afs_osi_proc2cred(AFS_PROC * pr)
-{
- struct AFS_UCRED *rv = NULL;
- static struct AFS_UCRED cr;
- struct ucred *pcred;
-
- if (pr == NULL) {
- return NULL;
- }
- pcred = proc_ucred(pr);
- cr.cr_ref = 1;
- cr.cr_uid = pcred->cr_uid;
- cr.cr_ngroups = pcred->cr_ngroups;
- memcpy(cr.cr_groups, pcred->cr_groups,
- NGROUPS * sizeof(gid_t));
- return &cr;
-}
#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
const struct AFS_UCRED *
afs_osi_proc2cred(AFS_PROC * pr)
/*
* Vnode related macros
*/
-#if defined(AFS_DARWIN80_ENV)
-#define vType(vc) vnode_vtype(AFSTOV(vc))
-#elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
#define vSetVfsp(vc, vfsp) AFSTOV(vc)->v_mount = (vfsp)
#define vSetType(vc, type) AFSTOV(vc)->v_type = (type)
#define vType(vc) AFSTOV(vc)->v_type
-extern int (**afs_vnodeop_p) ();
-#define IsAfsVnode(v) ((v)->v_op == afs_vnodeop_p)
-#define SetAfsVnode(v) /* nothing; done in getnewvnode() */
#else
#define vType(vc) (vc)->v.v_type
#define vSetType(vc,type) (vc)->v.v_type = (type)
#define vSetVfsp(vc,vfsp) (vc)->v.v_vfsp = (vfsp)
+#endif
+
+#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+extern int (**afs_vnodeop_p) ();
+#define IsAfsVnode(v) ((v)->v_op == afs_vnodeop_p)
+#define SetAfsVnode(v) /* nothing; done in getnewvnode() */
+#else
extern struct vnodeops *afs_ops;
#define IsAfsVnode(v) ((v)->v_op == afs_ops)
#define SetAfsVnode(v) (v)->v_op = afs_ops
AFS_GLOCK(); \
} while(0)
-#if defined(AFS_DARWIN80_ENV)
-#define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE) \
- do { \
- int haveGlock = ISAFS_GLOCK(); \
- if (haveGlock) \
- AFS_GUNLOCK(); \
- uio_setrw((UIO),(RW)); \
- CODE = uiomove((SRC),(LEN),(UIO)); \
- if (haveGlock) \
- AFS_GLOCK(); \
- } while(0)
-#else
#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
#define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE) \
do { \
AFS_GLOCK(); \
} while(0)
#endif
-#endif /* AFS_DARWIN80_ENV */
#else /* AFS_GLOBAL_SUNLOCK */
CODE = copyout((SRC),(DST),(LEN)); \
} while(0)
-#if defined(AFS_DARWIN80_ENV)
-#define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE) \
- do { \
- uio_setrw((UIO),(RW)); \
- CODE = uiomove((SRC),(LEN),(UIO)); \
- } while(0)
-#else /* AFS_OSF_ENV || AFS_FBSD_ENV */
#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
#define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE) \
do { \
CODE = uiomove((SRC),(LEN),(RW),(UIO)); \
} while(0)
#endif /* AFS_OSF_ENV || AFS_FBSD_ENV */
-#endif /* AFS_DARWIN80_ENV */
#endif /* AFS_GLOBAL_SUNLOCK */
-#ifdef AFS_DARWIN80_ENV
-#define AFS_UIO_OFFSET(uio) uio_offset(uio)
-#define AFS_UIO_RESID(uio) uio_resid(uio)
-#else
-#define AFS_UIO_OFFSET(uio) (uio)->uio_offset
-#define AFS_UIO_RESID(uio) (uio)->uio_resid
-#endif
-
-
/*
* encapsulation of kernel data structure accesses
*/
code = AddPag(genpag(), &credp);
crfree(credp);
}
-#elif defined(AFS_DARWIN80_ENV)
- {
- struct ucred *credp = kauth_cred_dup(proc_ucred(p));
- code = AddPag(p, genpag(), &credp);
- kauth_cred_rele(credp);
- }
#elif defined(AFS_DARWIN_ENV)
{
struct ucred *credp = crdup(p->p_cred->pc_ucred);
* UIO routines
*/
-#ifndef AFS_DARWIN80_ENV
/* routine to make copy of uio structure in ainuio, using aoutvec for space */
int
afsio_copy(struct uio *ainuio, struct uio *aoutuio,
}
return 0;
}
-#endif
/* skip asize bytes in the current uio structure */
int
register int cnt;
AFS_STATCNT(afsio_skip);
-#ifdef AFS_DARWIN80_ENV
- uio_update(auio, asize);
-#else
/* It isn't guaranteed that multiple iovecs work ok (hasn't been tested!) */
while (asize > 0 && auio->afsio_resid) {
tv = auio->afsio_iov;
auio->uio_offset += cnt;
asize -= cnt;
}
-#endif
return 0;
}
-#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN80_ENV)
+#if !defined(AFS_LINUX20_ENV)
/* This is the common part of the vget VFS call. */
int
afs_osi_vget(struct vcache **avcpp, struct fid *afidp, struct vrequest *areqp)
/* ARCH/osi_misc.c */
-#ifdef AFS_LINUX20_ENV
extern void osi_iput(struct inode *ip);
-#endif
extern void afs_osi_SetTime(osi_timeval_t * atv);
/* LINUX/osi_misc.c */
void
afsi_SetServerIPRank(sa, ifa)
struct srvAddr *sa;
-#ifdef AFS_DARWIN80_ENV
- ifaddr_t ifa;
-#else
struct ifaddr *ifa;
-#endif
{
- struct sockaddr sout;
struct sockaddr_in *sin;
int t;
afs_uint32 subnetmask, myAddr, myNet, myDstaddr, mySubnet, netMask;
afs_uint32 serverAddr;
- if (ifaddr_address_family(ifa) != AF_INET)
+ if (ifa->ifa_addr->sa_family != AF_INET)
return;
- t = ifaddr_address(ifa, &sout, sizeof(sout));
- if (t == 0) {
- sin = (struct sockaddr_in *)&sout;
- myAddr = ntohl(sin->sin_addr.s_addr); /* one of my IP addr in host order */
- } else {
- myAddr = 0;
- }
+ 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 */
- t = ifaddr_netmask(ifa, &sout, sizeof(sout));
- if (t == 0) {
- sin = (struct sockaddr_in *)&sout;
- subnetmask = ntohl(sin->sin_addr.s_addr); /* subnet mask in host order */
- } else {
- subnetmask = 0;
- }
- t = ifaddr_dstaddress(ifa, &sout, sizeof(sout));
- if (t == 0) {
- sin = (struct sockaddr_in *)&sout;
+ 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;
- } else {
- myDstaddr = 0;
- }
if (IN_CLASSA(myAddr))
netMask = IN_CLASSA_NET;
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 + ifnet_metric(ifaddr_ifnet(ifa)));
+ sa->sa_iprank = afs_min(sa->sa_iprank, HI + ifa->ifa_metric);
}
} else { /* same net */
- sa->sa_iprank = afs_min(sa->sa_iprank, MED + ifnet_metric(ifaddr_ifnet(ifa)));
+ sa->sa_iprank = afs_min(sa->sa_iprank, MED + ifa->ifa_metric);
}
}
#ifdef IFF_POINTTOPOINT
/* check for case #4 -- point-to-point link */
- if ((ifnet_flags(ifaddr_ifnet(ifa)) & IFF_POINTOPOINT)
+ if ((ifa->ia_ifp->if_flags & IFF_POINTOPOINT)
&& (myDstaddr == serverAddr)) {
- if (ifnet_metric(ifaddr_ifnet(ifa)) >= (MAXDEFRANK - MED) / PPWEIGHT)
+ if (ifa->ia_ifp->if_metric >= (MAXDEFRANK - MED) / PPWEIGHT)
t = MAXDEFRANK;
else
- t = MED + (PPWEIGHT << ifnet_metric(ifaddr_ifnet(ifa)));
+ t = MED + (PPWEIGHT << ifa->->ifa_metric);
if (sa->sa_iprank > t)
sa->sa_iprank = t;
}
#ifdef AFS_SGI62_ENV
(void)hash_enum(&hashinfo_inaddr, afsi_enum_set_rank, HTF_INET, NULL,
(caddr_t) sa, NULL);
-#elif defined(AFS_DARWIN80_ENV)
- {
- errno_t t;
- int cnt=0;
- ifaddr_t *addresses, address;
- t = ifnet_get_address_list_family(NULL, &addresses, AF_INET);
- if (t == 0) {
- while(addresses[cnt] != NULL) {
- afsi_SetServerIPRank(sa, address);
- cnt++;
- }
- ifnet_free_address_list(addresses);
- }
- }
#elif defined(AFS_DARWIN60_ENV)
{
struct ifnet *ifn;
#ifdef AFS_OSF_ENV
if (VREFCOUNT(tvc) > 1)
#else /* AFS_OSF_ENV */
-#ifdef AFS_DARWIN80_ENV
- if (vnode_isinuse(AFSTOV(tvc), 0))
-#else
if (VREFCOUNT(tvc))
-#endif
#endif
afs_warn("Stat cache entry at %x is held\n", tvc);
if (CheckLock(&tvc->lock))
/* OK, there are no internal vrefCounts, so there shouldn't
* be any more refs here. */
if (avc->v) {
-#ifdef AFS_DARWIN_ENV
- vnode_clearfsnode(AFSTOV(avc));
-#else
avc->v->v_data = NULL; /* remove from vnode */
-#endif
- AFSTOV(avc) = NULL; /* also drop the ptr to vnode */
+ avc->v = NULL; /* also drop the ptr to vnode */
}
#endif
afs_FreeAllAxs(&(avc->Access));
/* This should put it back on the vnode free list since usecount is 1 */
afs_vcount--;
vSetType(avc, VREG);
- if (VREFCOUNT_GT(avc,0)) {
+ if (VREFCOUNT(avc) > 0) {
VN_UNLOCK(AFSTOV(avc));
AFS_RELE(AFSTOV(avc));
} else {
refpanic("Exceeded pool of AFS vnodes(VLRU cycle?)");
else if (QNext(uq) != tq)
refpanic("VLRU inconsistent");
- else if (!VREFCOUNT_GT(tvc,0))
- refpanic("refcnt 0 on VLRU");
-
- if (VREFCOUNT_GT(tvc,0) && !VREFCOUNT_GT(tvc,1) &&
- tvc->opens == 0
+ else if (VREFCOUNT(tvc) < 1)
+ refpanic("refcnt 0 on VLRU");
+
+ if (VREFCOUNT(tvc) == 1 && tvc->opens == 0
&& (tvc->states & CUnlinkedDel) == 0) {
code = afs_FlushVCache(tvc, &fv_slept);
if (code == 0) {
}
#endif
-
- if (!VREFCOUNT_GT(tvc,0)
-#if defined(AFS_DARWIN_ENV) && !defined(UKERNEL) && !defined(AFS_DARWIN80_ENV)
- || ((VREFCOUNT(tvc) == 1) &&
- (UBCINFOEXISTS(AFSTOV(tvc))))
+ if (((VREFCOUNT(tvc) == 0)
+#if defined(AFS_DARWIN_ENV) && !defined(UKERNEL)
+ || ((VREFCOUNT(tvc) == 1) &&
+ (UBCINFOEXISTS(AFSTOV(tvc))))
#endif
- && tvc->opens == 0 && (tvc->states & CUnlinkedDel) == 0) {
+ ) && tvc->opens == 0 && (tvc->states & CUnlinkedDel) == 0) {
#if defined (AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
/*
* vgone() reclaims the vnode, which calls afs_FlushVCache(),
AFS_GUNLOCK();
afs_darwin_getnewvnode(tvc); /* includes one refcount */
AFS_GLOCK();
-#ifdef AFS_DARWIN80_ENV
- LOCKINIT(tvc->rwlock);
-#else
lockinit(&tvc->rwlock, PINOD, "vcache", 0, 0);
#endif
-#endif
#ifdef AFS_FBSD_ENV
{
struct vnode *vp;
/*
* That's because if we come in via the CUnlinkedDel bit state path we'll be have 0 refcnt
*/
- osi_Assert(VREFCOUNT_GT(tvc,0));
+ osi_Assert(VREFCOUNT(tvc) > 0);
AFS_RWLOCK((vnode_t *) tvc, VRWLOCK_WRITE);
#endif
ObtainWriteLock(&tvc->lock, 52);
#if defined(AFS_DARWIN_ENV)
iheldthelock = VOP_ISLOCKED(vp);
if (!iheldthelock)
- vnode_lock(vp);
+ vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, current_proc());
/* this is messy. we can call fsync which will try to reobtain this */
if (VTOAFS(vp) == tvc)
ReleaseWriteLock(&tvc->lock);
if (VTOAFS(vp) == tvc)
ObtainWriteLock(&tvc->lock, 954);
if (!iheldthelock)
-#ifdef AFS_DARWIN80_ENV
- vnode_unlock(vp);
-#else
VOP_UNLOCK(vp, LK_EXCLUSIVE, current_proc());
-#endif
#elif defined(AFS_FBSD60_ENV)
iheldthelock = VOP_ISLOCKED(vp, curthread);
if (!iheldthelock)
vms_delete(tvc->segid);
AFS_GLOCK();
tvc->segid = tvc->vmh = NULL;
- if (VREFCOUNT_GT(tvc,0))
+ if (VREFCOUNT(tvc))
osi_Panic("flushVcache: vm race");
}
if (tvc->credp) {
#define MyPidxx current->pid
#else
#if defined(AFS_DARWIN_ENV)
-#if defined(AFS_DARWIN80_ENV)
-#define MyPidxx (proc_selfpid())
-#else
#define MyPidxx (current_proc()->p_pid )
-#endif
#else
#if defined(AFS_FBSD_ENV)
#define MyPidxx (curproc->p_pid )
# include "h/dir.h"
#endif /* SGI || SUN || HPUX */
-#if !defined(AFS_SGI64_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_DARWIN80_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/uio.h>
# include <sys/mount.h>
# include <sys/namei.h>
-#ifdef AFS_DARWIN80_ENV
-# include <h/vnode.h>
-#else
# include <sys/vnode.h>
-#endif
# include <sys/queue.h>
# include <sys/malloc.h>
#ifndef AFS_FBSD_ENV
#undef timeout_fcn_t
#define _DIR_H_
#define doff_t int32_t
-#ifndef AFS_DARWIN80_ENV
# include <ufs/ufs/quota.h>
# include <ufs/ufs/inode.h>
# include <ufs/ffs/fs.h>
-#endif
#else
# include "h/vfs.h"
# include "h/vnode.h"
#if defined(__KERNEL__) && !defined(KDUMP_KERNEL)
#include <linux/threads.h>
+
#include <linux/config.h>
-#include <linux/string.h>
#ifdef CONFIG_SMP
#ifndef AFS_SMP
#define AFS_SMP 1
#define AFSBIG_ENDIAN 1
#define AFS_HAVE_FFS 1 /* Use system's ffs. */
-#define AFS_GCPAGS 0
+#define AFS_GCPAGS 1 /* if nonzero, garbage collect PAGs */
#define RXK_LISTENER_ENV 1
#ifdef KERNEL
#define va_nodeid va_fileid
#define vfs_vnodecovered mnt_vnodecovered
#define direct dirent
+#define vnode_t struct vnode
+//#define VN_RELE(vp) vrele(((struct vnode *)(vp)))
+//#define VN_HOLD(vp) VREF(((struct vnode *)(vp)))
#define BIND_8_COMPAT
#endif
KDEFS=
DBUG =
DEFINES= -D_KERNEL -DKERNEL -DKERNEL_PRIVATE -DDIAGNOSTIC -DUSE_SELECT -DMACH_USER_API -DMACH_KERNEL
-<ppc_darwin_80>
-KOPTS=-static -g -nostdinc -nostdlib -no-cpp-precomp -fno-builtin -finline -fno-keep-inline-functions -msoft-float -fsigned-bitfields -arch ppc -Dppc -DPPC -D__PPC__ -DPAGE_SIZE_FIXED -O2 -mcpu=750 -mmultiple -fschedule-insns
<ppc_darwin_70>
KOPTS=-static -fno-common -finline -fno-keep-inline-functions -force_cpusubtype_ALL -msoft-float -mlong-branch
<ppc_darwin_60>
RCSID
("$Header$");
-#ifndef AFS_DARWIN80_ENV
/*
* Currently everything is implemented in rx_kmutex.h
*/
-#else
-lck_grp_t * openafs_lck_grp;
-static lck_grp_attr_t * openafs_lck_grp_attr;
-void rx_kmutex_setup(void) {
- openafs_lck_grp_attr= lck_grp_attr_alloc_init();
- lck_grp_attr_setstat(openafs_lck_grp_attr);
-
- openafs_lck_grp = lck_grp_alloc_init("openafs", openafs_lck_grp_attr);
- lck_grp_attr_free(openafs_lck_grp_attr);
-
-}
-
-void rx_kmutex_finish(void) {
- lck_grp_free(openafs_lck_grp);
-}
-
-#endif
-
-
#define CV_BROADCAST(cv) thread_wakeup((event_t)(cv))
#endif
-#ifdef AFS_DARWIN80_ENV
-typedef struct {
- lck_mtx_t *lock;
- thread_t owner;
-} afs_kmutex_t;
-typedef int afs_kcondvar_t;
-
-extern lck_grp_t * openafs_lck_grp;
-
-#define MUTEX_SETUP() rx_kmutex_setup()
-#define MUTEX_FINISH() rx_kmutex_finish()
-#define LOCKINIT(a) \
- do { \
- lck_attr_t * openafs_lck_attr = lck_attr_alloc_init(); \
- (a) = lck_mtx_alloc_init(openafs_lck_grp, openafs_lck_attr); \
- lck_attr_free(openafs_lck_attr); \
- } while(0);
-#define MUTEX_INIT(a,b,c,d) \
- do { \
- lck_attr_t * openafs_lck_attr = lck_attr_alloc_init(); \
- (a)->lock = lck_mtx_alloc_init(openafs_lck_grp, openafs_lck_attr); \
- lck_attr_free(openafs_lck_attr); \
- (a)->owner = (thread_t)0; \
- } while(0);
-#define MUTEX_DESTROY(a) \
- do { \
- lck_mtx_destroy((a)->lock, openafs_lck_grp); \
- (a)->owner = (thread_t)-1; \
- } while(0);
-#define MUTEX_ENTER(a) \
- do { \
- lck_mtx_lock(&(a)->lock); \
- osi_Assert((a)->owner == (thread_t)0); \
- (a)->owner = current_thread(); \
- } while(0);
-#define MUTEX_TRYENTER(a) \
- (lck_mtx_try_lock(&(a)->lock) ? ((a)->owner = current_thread(), 1) : 0)
-#define MUTEX_EXIT(a) \
- do { \
- osi_Assert((a)->owner == current_thread()); \
- (a)->owner = (thread_t)0; \
- lck_mtx_unlock(&(a)->lock); \
- } while(0);
-
-#undef MUTEX_ISMINE
-#define MUTEX_ISMINE(a) (((afs_kmutex_t *)(a))->owner == current_thread())
-#else
typedef struct {
struct lock__bsd__ lock;
thread_t owner;
} afs_kmutex_t;
typedef int afs_kcondvar_t;
+#define osi_rxWakeup(cv) thread_wakeup((event_t)(cv))
+
#define LOCK_INIT(a,b) \
do { \
lockinit(&(a)->lock,PSOCK, "afs rx lock", 0, 0); \
} while(0);
#define MUTEX_TRYENTER(a) \
( lockmgr(&(a)->lock, LK_EXCLUSIVE|LK_NOWAIT, 0, current_proc()) ? 0 : ((a)->owner = current_thread(), 1) )
+#define xMUTEX_TRYENTER(a) \
+ ( osi_Assert((a)->owner == (thread_t)0), (a)->owner = current_thread(), 1)
#define MUTEX_EXIT(a) \
do { \
osi_Assert((a)->owner == current_thread()); \
#undef MUTEX_ISMINE
#define MUTEX_ISMINE(a) (((afs_kmutex_t *)(a))->owner == current_thread())
-#endif
#undef osirx_AssertMine
extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg);
#ifndef _XDR_PROTOTYPES_H
#define _XDR_PROTOTYPES_H
-struct rx_call;
+/* I don't like this, but some of these defs depend on rx.h */
+#if defined(KERNEL) && defined(UKERNEL)
+#include "afs/sysincludes.h"
+#include "rx/rx.h"
+#else
+#include "rx/rx.h"
+#endif
/* xdr_afsuuid.c */
extern int xdr_afsUUID(XDR * xdrs, afsUUID * objp);
projects / packages / o / openafs.git / commitdiff