#include <afsconfig.h>
#include "afs/param.h"
-RCSID
- ("$Header$");
#include "afs/sysincludes.h" /*Standard vendor system headers */
#include "afsincludes.h" /*AFS-based standard headers */
"afs_xosi", (char *)&afs_xosi},
#endif
{
- "afs_xsrvAddr", (char *)&afs_xsrvAddr}
+ "afs_xsrvAddr", (char *)&afs_xsrvAddr},
+ {
+ "afs_xvreclaim", (char *)&afs_xvreclaim},
+#ifdef AFS_AFSDB_ENV
+ { "afsdb_client_lock", (char *)&afsdb_client_lock},
+ { "afsdb_req_lock", (char *)&afsdb_req_lock},
+#endif
+#ifdef AFS_DISCON_ENV
+ { "afs_discon_lock", (char *)&afs_discon_lock},
+ { "afs_disconDirtyLock", (char *)&afs_disconDirtyLock},
+ { "afs_discon_vc_dirty", (char *)&afs_xvcdirty},
+#endif
};
unsigned long lastCallBack_vnode;
unsigned int lastCallBack_dv;
* Copy out the located entry.
*/
a_result->addr = afs_data_pointer_to_int32(tvc);
- a_result->cell = tvc->fid.Cell;
- a_result->netFid.Volume = tvc->fid.Fid.Volume;
- a_result->netFid.Vnode = tvc->fid.Fid.Vnode;
- a_result->netFid.Unique = tvc->fid.Fid.Unique;
+ a_result->cell = tvc->f.fid.Cell;
+ a_result->netFid.Volume = tvc->f.fid.Fid.Volume;
+ a_result->netFid.Vnode = tvc->f.fid.Fid.Vnode;
+ a_result->netFid.Unique = tvc->f.fid.Fid.Unique;
a_result->lock.waitStates = tvc->lock.wait_states;
a_result->lock.exclLocked = tvc->lock.excl_locked;
a_result->lock.readersReading = tvc->lock.readers_reading;
a_result->lock.numWaiting = tvc->lock.num_waiting;
#if defined(INSTRUMENT_LOCKS)
- a_result->lock.pid_last_reader = tvc->lock.pid_last_reader;
- a_result->lock.pid_writer = tvc->lock.pid_writer;
+ a_result->lock.pid_last_reader = MyPidxx2Pid(tvc->lock.pid_last_reader);
+ a_result->lock.pid_writer = MyPidxx2Pid(tvc->lock.pid_writer);
a_result->lock.src_indicator = tvc->lock.src_indicator;
#else
/* On osf20 , the vcache does not maintain these three fields */
a_result->lock.src_indicator = 0;
#endif /* AFS_OSF20_ENV */
#ifdef AFS_64BIT_CLIENT
- a_result->Length = (afs_int32) tvc->m.Length & 0xffffffff;
+ a_result->Length = (afs_int32) tvc->f.m.Length & 0xffffffff;
#else /* AFS_64BIT_CLIENT */
- a_result->Length = tvc->m.Length;
+ a_result->Length = tvc->f.m.Length;
#endif /* AFS_64BIT_CLIENT */
- a_result->DataVersion = hgetlo(tvc->m.DataVersion);
+ a_result->DataVersion = hgetlo(tvc->f.m.DataVersion);
a_result->callback = afs_data_pointer_to_int32(tvc->callback); /* XXXX Now a pointer; change it XXXX */
a_result->cbExpires = tvc->cbExpires;
+ if (tvc->f.states & CVInit) {
+ a_result->refCount = 1;
+ } else {
#ifdef AFS_DARWIN80_ENV
- a_result->refCount = vnode_isinuse(AFSTOV(tvc))?1:0; /* XXX fix */
+ 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->states = tvc->states;
+ a_result->states = tvc->f.states;
code = 0;
/*
* Copy out the located entry.
*/
a_result->addr = afs_data_pointer_to_int32(tvc);
- a_result->cell = tvc->fid.Cell;
- a_result->netFid.Volume = tvc->fid.Fid.Volume;
- a_result->netFid.Vnode = tvc->fid.Fid.Vnode;
- a_result->netFid.Unique = tvc->fid.Fid.Unique;
+ a_result->cell = tvc->f.fid.Cell;
+ a_result->netFid.Volume = tvc->f.fid.Fid.Volume;
+ a_result->netFid.Vnode = tvc->f.fid.Fid.Vnode;
+ a_result->netFid.Unique = tvc->f.fid.Fid.Unique;
a_result->lock.waitStates = tvc->lock.wait_states;
a_result->lock.exclLocked = tvc->lock.excl_locked;
a_result->lock.readersReading = tvc->lock.readers_reading;
a_result->lock.numWaiting = tvc->lock.num_waiting;
#if defined(INSTRUMENT_LOCKS)
- a_result->lock.pid_last_reader = tvc->lock.pid_last_reader;
- a_result->lock.pid_writer = tvc->lock.pid_writer;
+ a_result->lock.pid_last_reader = MyPidxx2Pid(tvc->lock.pid_last_reader);
+ a_result->lock.pid_writer = MyPidxx2Pid(tvc->lock.pid_writer);
a_result->lock.src_indicator = tvc->lock.src_indicator;
#else
/* On osf20 , the vcache does not maintain these three fields */
#endif /* AFS_OSF20_ENV */
#if !defined(AFS_64BIT_ENV)
a_result->Length.high = 0;
- a_result->Length.low = tvc->m.Length;
+ a_result->Length.low = tvc->f.m.Length;
#else
- a_result->Length = tvc->m.Length;
+ a_result->Length = tvc->f.m.Length;
#endif
- a_result->DataVersion = hgetlo(tvc->m.DataVersion);
+ a_result->DataVersion = hgetlo(tvc->f.m.DataVersion);
a_result->callback = afs_data_pointer_to_int32(tvc->callback); /* XXXX Now a pointer; change it XXXX */
a_result->cbExpires = tvc->cbExpires;
+ if (tvc->f.states & CVInit) {
+ a_result->refCount = 1;
+ } else {
#ifdef AFS_DARWIN80_ENV
- a_result->refCount = vnode_isinuse(AFSTOV(tvc))?1:0; /* XXX fix */
+ 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->states = tvc->states;
+ a_result->states = tvc->f.states;
code = 0;
/*
AFS_STATCNT(SRXAFSCB_GetLock);
nentries = sizeof(ltable) / sizeof(struct ltable);
- if (a_index < 0 || a_index >= nentries) {
+ if (a_index < 0 || a_index >= nentries+afs_cellindex) {
/*
* Past EOF
*/
code = 1;
+ } else if (a_index >= nentries) {
+ struct cell *tc = afs_GetCellByIndex(a_index-nentries, 0);
+ strcpy(a_result->name, tc->cellName);
+ a_result->lock.waitStates =
+ ((struct afs_lock *)&(tc->lock))->wait_states;
+ a_result->lock.exclLocked =
+ ((struct afs_lock *)&(tc->lock))->excl_locked;
+ a_result->lock.readersReading =
+ ((struct afs_lock *)&(tc->lock))->readers_reading;
+ a_result->lock.numWaiting =
+ ((struct afs_lock *)&(tc->lock))->num_waiting;
+#ifdef INSTRUMENT_LOCKS
+ a_result->lock.pid_last_reader =
+ MyPidxx2Pid(((struct afs_lock *)&(tc->lock))->pid_last_reader);
+ a_result->lock.pid_writer =
+ MyPidxx2Pid(((struct afs_lock *)&(tc->lock))->pid_writer);
+ a_result->lock.src_indicator =
+ ((struct afs_lock *)&(tc->lock))->src_indicator;
+#else
+ a_result->lock.pid_last_reader = 0;
+ a_result->lock.pid_writer = 0;
+ a_result->lock.src_indicator = 0;
+#endif
+ code = 0;
} else {
/*
* Found it - copy out its contents.
((struct afs_lock *)(tl->addr))->num_waiting;
#ifdef INSTRUMENT_LOCKS
a_result->lock.pid_last_reader =
- ((struct afs_lock *)(tl->addr))->pid_last_reader;
+ MyPidxx2Pid(((struct afs_lock *)(tl->addr))->pid_last_reader);
a_result->lock.pid_writer =
- ((struct afs_lock *)(tl->addr))->pid_writer;
+ MyPidxx2Pid(((struct afs_lock *)(tl->addr))->pid_writer);
a_result->lock.src_indicator =
((struct afs_lock *)(tl->addr))->src_indicator;
#else
register int i;
struct VenusFid localFid;
struct volume *tv;
+#ifdef AFS_DARWIN80_ENV
+ vnode_t vp;
+#endif
AFS_STATCNT(ClearCallBack);
*/
if (a_fid->Volume != 0) {
if (a_fid->Vnode == 0) {
+ struct afs_q *tq, *uq;
/*
* Clear callback for the whole volume. Zip through the
* hash chain, nullifying entries whose volume ID matches.
*/
- for (i = 0; i < VCSIZE; i++)
- for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
- if (tvc->fid.Fid.Volume == a_fid->Volume) {
+loop1:
+ ObtainReadLock(&afs_xvcache);
+ i = VCHashV(&localFid);
+ for (tq = afs_vhashTV[i].prev; tq != &afs_vhashTV[i]; tq = uq) {
+ uq = QPrev(tq);
+ tvc = QTOVH(tq);
+ if (tvc->f.fid.Fid.Volume == a_fid->Volume) {
tvc->callback = NULL;
- tvc->quick.stamp = 0;
if (!localFid.Cell)
- localFid.Cell = tvc->fid.Cell;
- tvc->h1.dchint = NULL; /* invalidate hints */
+ localFid.Cell = tvc->f.fid.Cell;
+ tvc->dchint = NULL; /* invalidate hints */
+ if (tvc->f.states & CVInit) {
+ ReleaseReadLock(&afs_xvcache);
+ afs_osi_Sleep(&tvc->f.states);
+ goto loop1;
+ }
+#ifdef AFS_DARWIN80_ENV
+ if (tvc->f.states & CDeadVnode) {
+ ReleaseReadLock(&afs_xvcache);
+ afs_osi_Sleep(&tvc->f.states);
+ goto loop1;
+ }
+#endif
+#if defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
+ VN_HOLD(AFSTOV(tvc));
+#else
+#ifdef AFS_DARWIN80_ENV
+ vp = AFSTOV(tvc);
+ if (vnode_get(vp))
+ continue;
+ if (vnode_ref(vp)) {
+ AFS_GUNLOCK();
+ vnode_put(vp);
+ AFS_GLOCK();
+ continue;
+ }
+#else
+#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+ osi_vnhold(tvc, 0);
+#else
+ VREFCOUNT_INC(tvc); /* AIX, apparently */
+#endif
+#endif
+#endif
+ ReleaseReadLock(&afs_xvcache);
ObtainWriteLock(&afs_xcbhash, 449);
afs_DequeueCallback(tvc);
- tvc->states &= ~(CStatd | CUnique | CBulkFetching);
+ tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
afs_allCBs++;
- if (tvc->fid.Fid.Vnode & 1)
+ if (tvc->f.fid.Fid.Vnode & 1)
afs_oddCBs++;
else
afs_evenCBs++;
ReleaseWriteLock(&afs_xcbhash);
- if (tvc->fid.Fid.Vnode & 1 || (vType(tvc) == VDIR))
+ if ((tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
osi_dnlc_purgedp(tvc);
afs_Trace3(afs_iclSetp, CM_TRACE_CALLBACK,
ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
- tvc->states, ICL_TYPE_INT32,
+ tvc->f.states, ICL_TYPE_INT32,
a_fid->Volume);
- } else if ((tvc->states & CMValid)
+#ifdef AFS_DARWIN80_ENV
+ vnode_put(AFSTOV(tvc));
+#endif
+ ObtainReadLock(&afs_xvcache);
+ uq = QPrev(tq);
+ AFS_FAST_RELE(tvc);
+ } else if ((tvc->f.states & CMValid)
&& (tvc->mvid->Fid.Volume == a_fid->Volume)) {
- tvc->states &= ~CMValid;
+ tvc->f.states &= ~CMValid;
if (!localFid.Cell)
localFid.Cell = tvc->mvid->Cell;
}
}
+ ReleaseReadLock(&afs_xvcache);
/*
* XXXX Don't hold any locks here XXXX
/*
* Clear callbacks just for the one file.
*/
+ struct vcache *uvc;
afs_allCBs++;
if (a_fid->Vnode & 1)
afs_oddCBs++; /*Could do this on volume basis, too */
else
afs_evenCBs++; /*A particular fid was specified */
+loop2:
+ ObtainReadLock(&afs_xvcache);
i = VCHash(&localFid);
- for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
- if (tvc->fid.Fid.Vnode == a_fid->Vnode
- && tvc->fid.Fid.Volume == a_fid->Volume
- && tvc->fid.Fid.Unique == a_fid->Unique) {
+ for (tvc = afs_vhashT[i]; tvc; tvc = uvc) {
+ uvc = tvc->hnext;
+ if (tvc->f.fid.Fid.Vnode == a_fid->Vnode
+ && tvc->f.fid.Fid.Volume == a_fid->Volume
+ && tvc->f.fid.Fid.Unique == a_fid->Unique) {
tvc->callback = NULL;
- tvc->quick.stamp = 0;
- tvc->h1.dchint = NULL; /* invalidate hints */
+ tvc->dchint = NULL; /* invalidate hints */
+ if (tvc->f.states & CVInit) {
+ ReleaseReadLock(&afs_xvcache);
+ afs_osi_Sleep(&tvc->f.states);
+ goto loop2;
+ }
+#ifdef AFS_DARWIN80_ENV
+ if (tvc->f.states & CDeadVnode) {
+ ReleaseReadLock(&afs_xvcache);
+ afs_osi_Sleep(&tvc->f.states);
+ goto loop2;
+ }
+#endif
+#if defined(AFS_SGI_ENV) || defined(AFS_OSF_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
+ VN_HOLD(AFSTOV(tvc));
+#else
+#ifdef AFS_DARWIN80_ENV
+ vp = AFSTOV(tvc);
+ if (vnode_get(vp))
+ continue;
+ if (vnode_ref(vp)) {
+ AFS_GUNLOCK();
+ vnode_put(vp);
+ AFS_GLOCK();
+ continue;
+ }
+#else
+#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+ osi_vnhold(tvc, 0);
+#else
+ VREFCOUNT_INC(tvc); /* AIX, apparently */
+#endif
+#endif
+#endif
+ ReleaseReadLock(&afs_xvcache);
ObtainWriteLock(&afs_xcbhash, 450);
afs_DequeueCallback(tvc);
- tvc->states &= ~(CStatd | CUnique | CBulkFetching);
+ tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
ReleaseWriteLock(&afs_xcbhash);
- if (a_fid->Vnode & 1 || (vType(tvc) == VDIR))
+ if ((tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
osi_dnlc_purgedp(tvc);
afs_Trace3(afs_iclSetp, CM_TRACE_CALLBACK,
ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
- tvc->states, ICL_TYPE_LONG, 0);
+ tvc->f.states, ICL_TYPE_LONG, 0);
#ifdef CBDEBUG
lastCallBack_vnode = afid->Vnode;
lastCallBack_dv = tvc->mstat.DataVersion.low;
osi_GetuTime(&lastCallBack_time);
#endif /* CBDEBUG */
+#ifdef AFS_DARWIN80_ENV
+ vnode_put(AFSTOV(tvc));
+#endif
+ ObtainReadLock(&afs_xvcache);
+ uvc = tvc->hnext;
+ AFS_FAST_RELE(tvc);
}
} /*Walk through hash table */
+ ReleaseReadLock(&afs_xvcache);
} /*Clear callbacks for one file */
}
ObtainWriteLock(&afs_xcbhash, 451);
afs_DequeueCallback(tvc);
tvc->callback = NULL;
- tvc->states &= ~(CStatd | CUnique | CBulkFetching);
+ tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
ReleaseWriteLock(&afs_xcbhash);
}
}
/*
* Donate this process to Rx.
*/
- rx_ServerProc();
+ rx_ServerProc(NULL);
return (0);
} /*afs_RXCallBackServer */
{
int i;
int code = 0;
- afs_int32 *dataBuffP;
+ afs_uint32 *dataBuffP;
afs_int32 dataBytes;
RX_AFS_GLOCK();
RX_AFS_GUNLOCK();
- dataBytes = 1 * sizeof(afs_int32);
- dataBuffP = (afs_int32 *) afs_osi_Alloc(dataBytes);
- dataBuffP[0] = CAPABILITY_ERRORTRANS;
- capabilities->Capabilities_len = dataBytes / sizeof(afs_int32);
+ dataBytes = 1 * sizeof(afs_uint32);
+ dataBuffP = (afs_uint32 *) afs_osi_Alloc(dataBytes);
+ dataBuffP[0] = CLIENT_CAPABILITY_ERRORTRANS;
+ capabilities->Capabilities_len = dataBytes / sizeof(afs_uint32);
capabilities->Capabilities_val = dataBuffP;
return code;
}
+
+
+#if 0 && defined(AFS_LINUX24_ENV)
+extern struct vcache *afs_globalVp;
+
+int recurse_dcache_parent(parent, a_index, addr, inode, flags, time, fileName)
+ struct dentry * parent;
+ afs_int32 a_index;
+ afs_int32 *addr;
+ afs_int32 *inode;
+ afs_int32 *flags;
+ afs_int32 *time;
+ char ** fileName;
+{
+ struct dentry *this_parent = parent;
+ struct list_head *next;
+ int found = 0;
+ struct dentry *dentry;
+
+repeat:
+ next = this_parent->d_subdirs.next;
+resume:
+ while (next != &this_parent->d_subdirs) {
+ struct list_head *tmp = next;
+ dentry = list_entry(tmp, struct dentry, d_child);
+ if (a_index == 0)
+ goto searchdone3;
+ a_index--;
+ next = tmp->next;
+ /*
+ * Descend a level if the d_subdirs list is non-empty.
+ */
+ if (!list_empty(&dentry->d_subdirs)) {
+ this_parent = dentry;
+ goto repeat;
+ }
+ }
+ /*
+ * All done at this level ... ascend and resume the search.
+ */
+ if (this_parent != parent) {
+ next = this_parent->d_child.next;
+ this_parent = this_parent->d_parent;
+ goto resume;
+ }
+ goto ret;
+
+ searchdone3:
+ if (d_unhashed(dentry))
+ *flags = 1;
+ else
+ *flags = 0;
+
+ *fileName = afs_strdup(dentry->d_name.name?dentry->d_name.name:"");
+ *inode = ITOAFS(dentry->d_inode);
+ *addr = atomic_read(&(dentry)->d_count);
+ *time = dentry->d_time;
+
+ return 0;
+ ret:
+ return 1;
+}
+#endif
+
+int SRXAFSCB_GetDE(a_call, a_index, addr, inode, flags, time, fileName)
+ struct rx_call *a_call;
+ afs_int32 a_index;
+ afs_int32 *addr;
+ afs_int32 *inode;
+ afs_int32 *flags;
+ afs_int32 *time;
+ char ** fileName;
+{ /*SRXAFSCB_GetDE*/
+ int code = 0; /*Return code*/
+#if 0 && defined(AFS_LINUX24_ENV)
+ register int i; /*Loop variable*/
+ register struct vcache *tvc = afs_globalVp;
+ struct dentry *dentry;
+ struct list_head *cur, *head = &(AFSTOI(tvc))->i_dentry;
+
+#ifdef RX_ENABLE_LOCKS
+ AFS_GLOCK();
+#endif /* RX_ENABLE_LOCKS */
+
+#if defined(AFS_LINUX24_ENV)
+ spin_lock(&dcache_lock);
+#endif
+
+ cur = head;
+ while ((cur = cur->next) != head) {
+ dentry = list_entry(cur, struct dentry, d_alias);
+
+ dget_locked(dentry);
+
+#if defined(AFS_LINUX24_ENV)
+ spin_unlock(&dcache_lock);
+#endif
+ if (a_index == 0)
+ goto searchdone2;
+ a_index--;
+
+ if (recurse_dcache_parent(dentry, a_index, addr, inode, flags, time, fileName) == 0) {
+ dput(dentry);
+ code = 0;
+ goto fcnDone;
+ }
+ dput(dentry);
+ }
+ searchdone2:
+ if (cur == head) {
+ /*Past EOF*/
+ code = 1;
+ *fileName = afs_strdup("");
+ goto fcnDone;
+ }
+
+ if (d_unhashed(dentry))
+ *flags = 1;
+ else
+ *flags = 0;
+
+ *fileName = afs_strdup(dentry->d_name.name?dentry->d_name.name:"");
+ *inode = ITOAFS(dentry->d_inode);
+ *addr = atomic_read(&(dentry)->d_count);
+ *time = dentry->d_time;
+
+ dput(dentry);
+ code = 0;
+
+fcnDone:
+
+#ifdef RX_ENABLE_LOCKS
+ AFS_GUNLOCK();
+#endif /* RX_ENABLE_LOCKS */
+#endif
+ return(code);
+
+} /*SRXAFSCB_GetDE*/