bp = cm_data.bufHeaderBaseAddress;
data = cm_data.bufDataBaseAddress;
+ lock_ObtainWrite(&buf_globalLock);
for (i=0; i<cm_data.buf_nbuffers; i++) {
lock_InitializeMutex(&bp->mx, "Buffer mutex", LOCK_HIERARCHY_BUFFER);
bp->userp = NULL;
* extent was not returned by the file system driver.
* clean up the mess.
*/
+ buf_RemoveFromRedirQueue(NULL, bp);
bp->dataVersion = CM_BUF_VERSION_BAD;
- _InterlockedAnd(&bp->qFlags, ~CM_BUF_QREDIR);
- osi_QRemoveHT( (osi_queue_t **) &cm_data.buf_redirListp,
- (osi_queue_t **) &cm_data.buf_redirListEndp,
- &bp->q);
- buf_DecrementRedirCount();
bp->redirq.nextp = bp->redirq.prevp = NULL;
bp->redirLastAccess = 0;
bp->redirReleaseRequested = 0;
- buf_Release(bp);
+ buf_ReleaseLocked(bp, TRUE);
+ InterlockedDecrement(&cm_data.buf_usedCount);
}
bp++;
}
* extent was not returned by the file system driver.
* clean up the mess.
*/
+ buf_RemoveFromRedirQueue(NULL, bp);
bp->dataVersion = CM_BUF_VERSION_BAD;
- _InterlockedAnd(&bp->qFlags, ~CM_BUF_QREDIR);
- osi_QRemoveHT( (osi_queue_t **) &cm_data.buf_redirListp,
- (osi_queue_t **) &cm_data.buf_redirListEndp,
- &bp->q);
- buf_DecrementRedirCount();
bp->redirq.nextp = bp->redirq.prevp = NULL;
bp->redirLastAccess = 0;
bp->redirReleaseRequested = 0;
- buf_Release(bp);
+ buf_ReleaseLocked(bp, TRUE);
+ InterlockedDecrement(&cm_data.buf_usedCount);
}
+ lock_ReleaseWrite(&buf_globalLock);
}
#ifdef TESTING
}
if ( scp ) {
lock_ObtainRead(&scp->rw);
- if (scp->flags & CM_SCACHEFLAG_WAITING) {
+ if (!osi_QIsEmpty(&scp->waitQueueH)) {
osi_Log1(buf_logp, "buf_WaitIO waking scp 0x%p", scp);
osi_Wakeup((LONG_PTR)&scp->flags);
}
* that the cm_scache_t was recycled out of the cache even though
* a cm_buf_t with the same FID is in the cache.
*/
- if (scp == NULL) {
- if ((scp = cm_FindSCache(&bp->fid)) ||
- (cm_GetSCache(&bp->fid, &scp,
- bp->userp ? bp->userp : cm_rootUserp,
- reqp) == 0)) {
- release_scp = 1;
+ if (scp == NULL &&
+ cm_GetSCache(&bp->fid, NULL, &scp,
+ bp->userp ? bp->userp : cm_rootUserp,
+ reqp) == 0)
+ {
+ release_scp = 1;
+
+ lock_ObtainWrite(&scp->rw);
+ code = cm_SyncOp(scp, NULL, bp->userp ? bp->userp : cm_rootUserp, reqp, 0,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (code == 0) {
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
}
+ lock_ReleaseWrite(&scp->rw);
+ }
+
+ if (scp && (scp->flags & CM_SCACHEFLAG_DELETED)) {
+ _InterlockedAnd(&bp->flags, ~CM_BUF_DIRTY);
+ _InterlockedOr(&bp->flags, CM_BUF_ERROR);
+ bp->dirty_length = 0;
+ bp->error = code;
+ bp->dataVersion = CM_BUF_VERSION_BAD;
+ bp->dirtyCounter++;
+ InterlockedDecrement(&cm_data.buf_usedCount);
}
while ((bp->flags & CM_BUF_DIRTY) == CM_BUF_DIRTY) {
* to determine if it is appropriate to fill a full chunk of data
* when storing to the file server.
*/
- code = (*cm_buf_opsp->Writep)(scp, &offset,
- bp->dirty_length,
- flags, bp->userp, reqp);
+ code = (*cm_buf_opsp->Writep)(scp, &offset, bp->dirty_length, flags,
+ bp->userp ? bp->userp : cm_rootUserp, reqp);
osi_Log3(buf_logp, "buf_CleanLocked I/O on scp 0x%p buf 0x%p, done=%d", scp, bp, code);
}
lock_ObtainMutex(&bp->mx);
*/
if (code == CM_ERROR_NOSUCHFILE || code == CM_ERROR_BADFD || code == CM_ERROR_NOACCESS ||
code == CM_ERROR_QUOTA || code == CM_ERROR_SPACE || code == CM_ERROR_TOOBIG ||
- code == CM_ERROR_READONLY || code == CM_ERROR_NOSUCHPATH){
+ code == CM_ERROR_READONLY || code == CM_ERROR_NOSUCHPATH || code == EIO ||
+ code == CM_ERROR_INVAL || code == CM_ERROR_INVAL_NET_RESP || code == CM_ERROR_UNKNOWN){
_InterlockedAnd(&bp->flags, ~CM_BUF_DIRTY);
_InterlockedOr(&bp->flags, CM_BUF_ERROR);
- bp->dirty_offset = 0;
bp->dirty_length = 0;
bp->error = code;
bp->dataVersion = CM_BUF_VERSION_BAD;
bp->dirtyCounter++;
+ InterlockedDecrement(&cm_data.buf_usedCount);
break;
}
if (reqp->flags & CM_REQ_NORETRY)
break;
- /* Ditto if the hardDeadTimeout or idleTimeout was reached */
+ /*
+ * Ditto if the hardDeadTimeout or idleTimeout was reached
+ * Or a fatal error is received.
+ */
if (code == CM_ERROR_TIMEDOUT || code == CM_ERROR_ALLDOWN ||
code == CM_ERROR_ALLBUSY || code == CM_ERROR_ALLOFFLINE ||
- code == CM_ERROR_CLOCKSKEW) {
+ code == CM_ERROR_CLOCKSKEW || code == CM_ERROR_INVAL_NET_RESP ||
+ code == CM_ERROR_INVAL || code == CM_ERROR_UNKNOWN || code == EIO) {
break;
}
}
cm_buf_t *bp; /* buffer we're dealing with */
cm_buf_t *nextBp; /* next buffer in file hash chain */
afs_uint32 i; /* temp */
- afs_uint64 n_bufs, n_nonzero, n_busy, n_dirty, n_own;
+ afs_uint64 n_bufs, n_nonzero, n_busy, n_dirty, n_own, n_redir;
#ifdef TESTING
buf_ValidateBufQueues();
n_own = 0;
n_busy = 0;
n_dirty = 0;
+ n_redir = 0;
lock_ObtainRead(&scp->bufCreateLock);
lock_ObtainWrite(&buf_globalLock);
continue;
}
+ /* leave the buffer alone if held by the redirector */
+ if (bp->qFlags & CM_BUF_QREDIR) {
+ n_redir++;
+ continue;
+ }
+
if (bp->flags & CM_BUF_DIRTY) {
n_dirty++;
- /* leave the buffer alone if held by the redirector */
- if (bp->qFlags & CM_BUF_QREDIR)
- continue;
-
/* protect against cleaning the same buffer more than once. */
if (cleaned)
continue;
osi_panic("buf_GetNewLocked: TryMutex failed",__FILE__,__LINE__);
}
+ if ( cm_data.buf_usedCount < cm_data.buf_nbuffers)
+ InterlockedIncrement(&cm_data.buf_usedCount);
+
lock_ReleaseWrite(&buf_globalLock);
lock_ReleaseRead(&scp->bufCreateLock);
lock_ReleaseWrite(&buf_globalLock);
lock_ReleaseRead(&scp->bufCreateLock);
- osi_Log1(afsd_logp, "buf_GetNewLocked: Free Buffer List has %u buffers none free", n_bufs);
+ osi_Log2(afsd_logp, "buf_GetNewLocked: Free Buffer List has %u buffers none free; redir %u", n_bufs, n_redir);
osi_Log4(afsd_logp, "... nonzero %u; own %u; busy %u; dirty %u", n_nonzero, n_own, n_busy, n_dirty);
if (RDR_Initialized) {
{
osi_assertx(bp->magic == CM_BUF_MAGIC, "invalid cm_buf_t magic");
osi_assertx(bp->refCount > 0, "cm_buf_t refcount 0");
+ osi_assertx(userp != NULL, "userp is NULL");
if (length == 0)
return;
}
_InterlockedAnd(&bufp->flags, ~CM_BUF_DIRTY);
bufp->error = 0;
- bufp->dirty_offset = 0;
bufp->dirty_length = 0;
bufp->dataVersion = CM_BUF_VERSION_BAD; /* known bad */
bufp->dirtyCounter++;
+ InterlockedDecrement(&cm_data.buf_usedCount);
}
else {
/* don't set dirty, since dirty implies
_InterlockedAnd(&bp->flags, ~CM_BUF_DIRTY);
_InterlockedOr(&bp->flags, CM_BUF_ERROR);
bp->error = CM_ERROR_BADFD;
- bp->dirty_offset = 0;
bp->dirty_length = 0;
bp->dataVersion = CM_BUF_VERSION_BAD; /* known bad */
bp->dirtyCounter++;
lock_ReleaseMutex(&bp->mx);
+ InterlockedDecrement(&cm_data.buf_usedCount);
} else if (!(scp->flags & CM_SCACHEFLAG_RO)) {
if (code) {
goto skip;
buf_HoldLocked(nbp);
buf_ReleaseLocked(bp, TRUE);
didRelease = 1;
+ if (bp->dataVersion != CM_BUF_VERSION_BAD)
+ InterlockedDecrement(&cm_data.buf_usedCount);
buf_Recycle(bp);
}
}
for (bp = cm_data.buf_fileHashTablepp[i]; bp; bp = bp->fileHashp) {
if (cm_FidCmp(&bp->fid, &scp->fid) == 0) {
bp->dataVersion = CM_BUF_VERSION_BAD;
+ InterlockedDecrement(&cm_data.buf_usedCount);
found = 1;
}
}
switch (code) {
case CM_ERROR_NOSUCHFILE:
+ case CM_ERROR_INVAL:
case CM_ERROR_BADFD:
case CM_ERROR_NOACCESS:
case CM_ERROR_QUOTA:
case CM_ERROR_TOOBIG:
case CM_ERROR_READONLY:
case CM_ERROR_NOSUCHPATH:
+ case EIO:
+ case CM_ERROR_INVAL_NET_RESP:
+ case CM_ERROR_UNKNOWN:
/*
* Apply the previous fatal error to this buffer.
* Do not waste the time attempting to store to
*/
_InterlockedAnd(&bp->flags, ~CM_BUF_DIRTY);
_InterlockedOr(&bp->flags, CM_BUF_ERROR);
- bp->dirty_offset = 0;
bp->dirty_length = 0;
bp->error = code;
bp->dataVersion = CM_BUF_VERSION_BAD;
bp->dirtyCounter++;
+ InterlockedDecrement(&cm_data.buf_usedCount);
break;
case CM_ERROR_TIMEDOUT:
case CM_ERROR_ALLDOWN:
}
}
lock_ReleaseRead(&buf_globalLock);
- return 0;
+ return found;
}
long buf_RDRBuffersExist(cm_fid_t *fidp)
lock_ObtainMutex(&bp->mx);
_InterlockedAnd(&bp->cmFlags, ~CM_BUF_CMSTORING);
_InterlockedAnd(&bp->flags, ~CM_BUF_DIRTY);
- bp->dirty_offset = 0;
bp->dirty_length = 0;
_InterlockedOr(&bp->flags, CM_BUF_ERROR);
bp->error = VNOVNODE;
}
lock_ReleaseMutex(&bp->mx);
buf_Release(bp);
+ InterlockedDecrement(&cm_data.buf_usedCount);
}
}
return 0;
{
lock_AssertWrite(&buf_globalLock);
- lock_ObtainMutex(&scp->redirMx);
+ if (scp) {
+ lock_ObtainMutex(&scp->redirMx);
+ }
if (bufp->qFlags & CM_BUF_QINLRU) {
_InterlockedAnd(&bufp->qFlags, ~CM_BUF_QINLRU);
&bufp->redirq);
scp->redirLastAccess = bufp->redirLastAccess;
InterlockedIncrement(&scp->redirBufCount);
- }
- lock_ReleaseMutex(&scp->redirMx);
+ lock_ReleaseMutex(&scp->redirMx);
+ }
}
void
if (!(bufp->qFlags & CM_BUF_QREDIR))
return;
- lock_ObtainMutex(&scp->redirMx);
+ if (scp) {
+ lock_ObtainMutex(&scp->redirMx);
+ }
_InterlockedAnd(&bufp->qFlags, ~CM_BUF_QREDIR);
osi_QRemoveHT( (osi_queue_t **) &cm_data.buf_redirListp,
(osi_queue_t **) &cm_data.buf_redirListEndp,
&bufp->q);
buf_DecrementRedirCount();
+
if (scp) {
osi_QRemoveHT( (osi_queue_t **) &scp->redirQueueH,
(osi_queue_t **) &scp->redirQueueT,
&bufp->redirq);
+
InterlockedDecrement(&scp->redirBufCount);
+ lock_ReleaseMutex(&scp->redirMx);
}
-
- lock_ReleaseMutex(&scp->redirMx);
}
void
if (!(bufp->qFlags & CM_BUF_QREDIR))
return;
- lock_ObtainMutex(&scp->redirMx);
+ if (scp) {
+ lock_ObtainMutex(&scp->redirMx);
+ }
osi_QRemoveHT( (osi_queue_t **) &cm_data.buf_redirListp,
(osi_queue_t **) &cm_data.buf_redirListEndp,
(osi_queue_t **) &scp->redirQueueT,
&bufp->redirq);
scp->redirLastAccess = bufp->redirLastAccess;
- }
- lock_ReleaseMutex(&scp->redirMx);
+ lock_ReleaseMutex(&scp->redirMx);
+ }
}
git://git.openafs.org / openafs.git / blobdiff