/**
* Reset volume information for all volume structs that
* point to a speicific server.
* @param srvp
*/
void
afs_ResetVolumes(struct server *srvp)
{
int j, k;
struct volume *vp;
/* Find any volumes residing on this server and flush their state */
for (j = 0; j < NVOLS; j++) {
for (vp = afs_volumes[j]; vp; vp = vp->next) {
for (k = 0; k < MAXHOSTS; k++) {
if (!srvp || (vp->serverHost[k] == srvp)) {
vp->serverHost[k] = 0;
afs_ResetVolumeInfo(vp);
break;
}
}
}
}
}
/**
* Reset volume name to volume id mapping cache.
* @param flags
*/
void
afs_CheckVolumeNames(int flags)
{
afs_int32 i, j;
struct volume *tv;
unsigned int now;
struct vcache *tvc;
afs_int32 *volumeID, *cellID, vsize, nvols;
#ifdef AFS_DARWIN80_ENV
vnode_t tvp;
#endif
AFS_STATCNT(afs_CheckVolumeNames);
nvols = 0;
volumeID = cellID = NULL;
vsize = 0;
ObtainReadLock(&afs_xvolume);
if (flags & AFS_VOLCHECK_EXPIRED) {
/*
* allocate space to hold the volumeIDs and cellIDs, only if
* we will be invalidating the mountpoints later on
*/
for (i = 0; i < NVOLS; i++)
for (tv = afs_volumes[i]; tv; tv = tv->next)
++vsize;
volumeID = afs_osi_Alloc(2 * vsize * sizeof(*volumeID));
cellID = (volumeID) ? volumeID + vsize : 0;
}
now = osi_Time();
for (i = 0; i < NVOLS; i++) {
for (tv = afs_volumes[i]; tv; tv = tv->next) {
if (flags & AFS_VOLCHECK_EXPIRED) {
if (((tv->expireTime < (now + 10)) && (tv->states & VRO))
|| (flags & AFS_VOLCHECK_FORCE)) {
afs_ResetVolumeInfo(tv); /* also resets status */
if (volumeID) {
volumeID[nvols] = tv->volume;
cellID[nvols] = tv->cell;
}
++nvols;
continue;
}
}
/* ??? */
if (flags & (AFS_VOLCHECK_BUSY | AFS_VOLCHECK_FORCE)) {
for (j = 0; j < AFS_MAXHOSTS; j++)
tv->status[j] = not_busy;
}
}
}
ReleaseReadLock(&afs_xvolume);
/* next ensure all mt points are re-evaluated */
if (nvols || (flags & (AFS_VOLCHECK_FORCE | AFS_VOLCHECK_MTPTS))) {
loop:
ObtainReadLock(&afs_xvcache);
for (i = 0; i < VCSIZE; i++) {
for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
/* if the volume of "mvid" of the vcache entry is among the
* ones we found earlier, then we re-evaluate it. Also, if the
* force bit is set or we explicitly asked to reevaluate the
* mt-pts, we clean the cmvalid bit */
if ((flags & (AFS_VOLCHECK_FORCE | AFS_VOLCHECK_MTPTS))
|| (tvc->mvid
&& inVolList(tvc->mvid, nvols, volumeID, cellID)))
tvc->f.states &= ~CMValid;
/* If the volume that this file belongs to was reset earlier,
* then we should remove its callback.
* Again, if forced, always do it.
*/
if ((tvc->f.states & CRO)
&& (inVolList(&tvc->f.fid, nvols, volumeID, cellID)
|| (flags & AFS_VOLCHECK_FORCE))) {
if (tvc->f.states & CVInit) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop;
}
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop;
}
tvp = AFSTOV(tvc);
if (vnode_get(tvp))
continue;
if (vnode_ref(tvp)) {
AFS_GUNLOCK();
/* AFSTOV(tvc) may be NULL */
vnode_put(tvp);
AFS_GLOCK();
continue;
}
#else
AFS_FAST_HOLD(tvc);
#endif
ReleaseReadLock(&afs_xvcache);
ObtainWriteLock(&afs_xcbhash, 485);
/* LOCKXXX: We aren't holding tvc write lock? */
afs_DequeueCallback(tvc);
tvc->f.states &= ~CStatd;
ReleaseWriteLock(&afs_xcbhash);
if (tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR))
osi_dnlc_purgedp(tvc);
#ifdef AFS_DARWIN80_ENV
vnode_put(AFSTOV(tvc));
/* our tvc ptr is still good until now */
AFS_FAST_RELE(tvc);
ObtainReadLock(&afs_xvcache);
#else
ObtainReadLock(&afs_xvcache);
/* our tvc ptr is still good until now */
AFS_FAST_RELE(tvc);
#endif
}
}
}
osi_dnlc_purge(); /* definitely overkill, but it's safer this way. */
ReleaseReadLock(&afs_xvcache);
}
if (volumeID)
afs_osi_Free(volumeID, 2 * vsize * sizeof(*volumeID));
} /*afs_CheckVolumeNames */
int
SRXAFSCB_InitCallBackState(struct rx_call *a_call)
{
int i;
struct vcache *tvc;
struct rx_connection *tconn;
struct rx_peer *peer;
struct server *ts;
int code = 0;
XSTATS_DECLS;
RX_AFS_GLOCK();
XSTATS_START_CMTIME(AFS_STATS_CM_RPCIDX_INITCALLBACKSTATE);
AFS_STATCNT(SRXAFSCB_InitCallBackState);
/*
* Find the address of the host making this call
*/
if ((tconn = rx_ConnectionOf(a_call)) && (peer = rx_PeerOf(tconn))) {
afs_allCBs++;
afs_oddCBs++; /*Including any missed via create race */
afs_evenCBs++; /*Including any missed via create race */
ts = afs_FindServer(rx_HostOf(peer), rx_PortOf(peer), (afsUUID *) 0,
0);
if (ts) {
for (i = 0; i < VCSIZE; i++)
for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
if (tvc->callback == ts) {
ObtainWriteLock(&afs_xcbhash, 451);
afs_DequeueCallback(tvc);
tvc->callback = NULL;
tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
ReleaseWriteLock(&afs_xcbhash);
}
}
/* capabilities need be requested again */
ObtainWriteLock(&afs_xserver, 877);
ts->flags &= ~SCAPS_KNOWN;
ReleaseWriteLock(&afs_xserver);
}
/* find any volumes residing on this server and flush their state */
{
struct volume *tv;
int j;
for (i = 0; i < NVOLS; i++)
for (tv = afs_volumes[i]; tv; tv = tv->next) {
for (j = 0; j < AFS_MAXHOSTS; j++)
if (tv->serverHost[j] == ts)
afs_ResetVolumeInfo(tv);
}
}
osi_dnlc_purge(); /* may be a little bit extreme */
}
XSTATS_END_TIME;
RX_AFS_GUNLOCK();
return (0);
} /*SRXAFSCB_InitCallBackState */
void
afs_CheckCallbacks(unsigned int secs)
{
struct vcache *tvc;
register struct afs_q *tq;
struct afs_q *uq;
afs_uint32 now;
struct volume *tvp;
register int safety;
ObtainWriteLock(&afs_xcbhash, 85); /* pretty likely I'm going to remove something */
now = osi_Time();
for (safety = 0, tq = cbHashT[base].head.prev;
(safety <= CBQ_LIMIT) && (tq != &(cbHashT[base].head));
tq = uq, safety++) {
uq = QPrev(tq);
tvc = CBQTOV(tq);
if (tvc->cbExpires < now + secs) { /* race #1 here */
/* Get the volume, and if its callback expiration time is more than secs
* seconds into the future, update this vcache entry and requeue it below
*/
if ((tvc->f.states & CRO)
&& (tvp = afs_FindVolume(&(tvc->f.fid), READ_LOCK))) {
if (tvp->expireTime > now + secs) {
tvc->cbExpires = tvp->expireTime; /* XXX race here */
} else {
int i;
for (i = 0; i < MAXHOSTS && tvp->serverHost[i]; i++) {
if (!(tvp->serverHost[i]->flags & SRVR_ISDOWN)) {
/* What about locking xvcache or vrefcount++ or
* write locking tvc? */
QRemove(tq);
tvc->f.states &= ~(CStatd | CMValid | CUnique);
if (!(tvc->f.states & (CVInit|CVFlushed)) &&
(tvc->f.fid.Fid.Vnode & 1 ||
(vType(tvc) == VDIR)))
osi_dnlc_purgedp(tvc);
tvc->dchint = NULL; /*invalidate em */
afs_ResetVolumeInfo(tvp);
break;
}
}
}
afs_PutVolume(tvp, READ_LOCK);
} else {
/* Do I need to worry about things like execsorwriters?
* What about locking xvcache or vrefcount++ or write locking tvc?
*/
QRemove(tq);
tvc->f.states &= ~(CStatd | CMValid | CUnique);
if (!(tvc->f.states & (CVInit|CVFlushed)) &&
(tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
osi_dnlc_purgedp(tvc);
}
}
if ((tvc->cbExpires > basetime) && CBHash(tvc->cbExpires - basetime)) {
/* it's been renewed on us. Have to be careful not to put it back
* into this slot, or we may never get out of here.
*/
int slot;
slot = (CBHash(tvc->cbExpires - basetime) + base) % CBHTSIZE;
if (slot != base) {
if (QPrev(tq))
QRemove(&(tvc->callsort));
QAdd(&(cbHashT[slot].head), &(tvc->callsort));
/* XXX remember to update volume expiration time */
/* -- not needed for correctness, though */
}
}
}
if (safety > CBQ_LIMIT) {
afs_stats_cmperf.cbloops++;
if (afs_paniconwarn)
osi_Panic("CheckCallbacks");
afs_warn
("AFS Internal Error (minor): please contact AFS Product Support.\n");
ReleaseWriteLock(&afs_xcbhash);
afs_FlushCBs();
return;
} else
ReleaseWriteLock(&afs_xcbhash);
/* XXX future optimization:
if this item has been recently accessed, queue up a stat for it.
{
struct dcache * adc;
ObtainReadLock(&afs_xdcache);
if ((adc = tvc->quick.dc) && (adc->stamp == tvc->quick.stamp)
&& (afs_indexTimes[adc->index] > afs_indexCounter - 20)) {
queue up the stat request
}
ReleaseReadLock(&afs_xdcache);
}
*/
return;
} /* afs_CheckCallback */
static int
ClearCallBack(struct rx_connection *a_conn,
struct AFSFid *a_fid)
{
struct vcache *tvc;
int i;
struct VenusFid localFid;
struct volume *tv;
#ifdef AFS_DARWIN80_ENV
vnode_t vp;
#endif
AFS_STATCNT(ClearCallBack);
AFS_ASSERT_GLOCK();
/*
* XXXX Don't hold any server locks here because of callback protocol XXX
*/
localFid.Cell = 0;
localFid.Fid.Volume = a_fid->Volume;
localFid.Fid.Vnode = a_fid->Vnode;
localFid.Fid.Unique = a_fid->Unique;
/*
* Volume ID of zero means don't do anything.
*/
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.
*/
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;
if (!localFid.Cell)
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;
}
#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
AFS_FAST_HOLD(tvc);
#else
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
if (!(tvc->f.states & CBulkFetching)) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop1;
}
}
vp = AFSTOV(tvc);
if (vnode_get(vp))
continue;
if (vnode_ref(vp)) {
AFS_GUNLOCK();
vnode_put(vp);
AFS_GLOCK();
continue;
}
if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
AFS_GUNLOCK();
vnode_recycle(AFSTOV(tvc));
AFS_GLOCK();
}
#else
AFS_FAST_HOLD(tvc);
#endif
#endif
ReleaseReadLock(&afs_xvcache);
ObtainWriteLock(&afs_xcbhash, 449);
afs_DequeueCallback(tvc);
tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
afs_allCBs++;
if (tvc->f.fid.Fid.Vnode & 1)
afs_oddCBs++;
else
afs_evenCBs++;
ReleaseWriteLock(&afs_xcbhash);
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->f.states, ICL_TYPE_INT32,
a_fid->Volume);
#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->f.states &= ~CMValid;
if (!localFid.Cell)
localFid.Cell = tvc->mvid->Cell;
}
}
ReleaseReadLock(&afs_xvcache);
/*
* XXXX Don't hold any locks here XXXX
*/
tv = afs_FindVolume(&localFid, 0);
if (tv) {
afs_ResetVolumeInfo(tv);
afs_PutVolume(tv, 0);
/* invalidate mtpoint? */
}
} /*Clear callbacks for whole volume */
else {
/*
* 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 = 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->dchint = NULL; /* invalidate hints */
if (tvc->f.states & CVInit) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop2;
}
#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
AFS_FAST_HOLD(tvc);
#else
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
if (!(tvc->f.states & CBulkFetching)) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop2;
}
}
vp = AFSTOV(tvc);
if (vnode_get(vp))
continue;
if (vnode_ref(vp)) {
AFS_GUNLOCK();
vnode_put(vp);
AFS_GLOCK();
continue;
}
if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
AFS_GUNLOCK();
vnode_recycle(AFSTOV(tvc));
AFS_GLOCK();
}
#else
AFS_FAST_HOLD(tvc);
#endif
#endif
ReleaseReadLock(&afs_xvcache);
ObtainWriteLock(&afs_xcbhash, 450);
afs_DequeueCallback(tvc);
tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
ReleaseWriteLock(&afs_xcbhash);
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->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 */
}
/*Fid has non-zero volume ID */
/*
* Always return a predictable value.
*/
return (0);
} /*ClearCallBack */