}
}
-/* incremental sync daemon. Writes all dirty buffers every 5000 ms */
-void buf_IncrSyncer(long parm)
+long
+buf_Sync(int quitOnShutdown)
{
cm_buf_t **bpp, *bp, *prevbp;
- long i; /* counter */
- long wasDirty = 0;
+ afs_uint32 wasDirty = 0;
cm_req_t req;
- while (buf_ShutdownFlag == 0) {
- if (!wasDirty) {
- i = SleepEx(5000, 1);
- if (i != 0) continue;
- }
+ /* go through all of the dirty buffers */
+ lock_ObtainRead(&buf_globalLock);
+ for (bpp = &cm_data.buf_dirtyListp, prevbp = NULL; bp = *bpp; ) {
+ if (quitOnShutdown && buf_ShutdownFlag)
+ break;
- wasDirty = 0;
+ lock_ReleaseRead(&buf_globalLock);
+ /* all dirty buffers are held when they are added to the
+ * dirty list. No need for an additional hold.
+ */
+ lock_ObtainMutex(&bp->mx);
- /* go through all of the dirty buffers */
- lock_ObtainRead(&buf_globalLock);
- for (bpp = &cm_data.buf_dirtyListp, prevbp = NULL; bp = *bpp; ) {
- lock_ReleaseRead(&buf_globalLock);
- /* all dirty buffers are held when they are added to the
- * dirty list. No need for an additional hold.
- */
- lock_ObtainMutex(&bp->mx);
+ if (bp->flags & CM_BUF_DIRTY && !(bp->flags & CM_BUF_REDIR)) {
+ /* start cleaning the buffer; don't touch log pages since
+ * the log code counts on knowing exactly who is writing
+ * a log page at any given instant.
+ *
+ * only attempt to write the buffer if the volume might
+ * be online.
+ */
+ afs_uint32 dirty;
+ cm_volume_t * volp;
- if (bp->flags & CM_BUF_DIRTY) {
- /* start cleaning the buffer; don't touch log pages since
- * the log code counts on knowing exactly who is writing
- * a log page at any given instant.
- */
- cm_InitReq(&req);
- req.flags |= CM_REQ_NORETRY;
- wasDirty |= buf_CleanAsyncLocked(bp, &req);
- }
+ volp = cm_GetVolumeByFID(&bp->fid);
+ switch (cm_GetVolumeStatus(volp, bp->fid.volume)) {
+ case vl_online:
+ case vl_unknown:
+ cm_InitReq(&req);
+ req.flags |= CM_REQ_NORETRY;
+ buf_CleanAsyncLocked(bp, &req, &dirty);
+ wasDirty |= dirty;
+ }
+ cm_PutVolume(volp);
+ }
- /* the buffer may or may not have been dirty
- * and if dirty may or may not have been cleaned
- * successfully. check the dirty flag again.
- */
- if (!(bp->flags & CM_BUF_DIRTY)) {
- /* remove the buffer from the dirty list */
- lock_ObtainWrite(&buf_globalLock);
+ /* the buffer may or may not have been dirty
+ * and if dirty may or may not have been cleaned
+ * successfully. check the dirty flag again.
+ */
+ if (!(bp->flags & CM_BUF_DIRTY)) {
+ /* remove the buffer from the dirty list */
+ lock_ObtainWrite(&buf_globalLock);
#ifdef DEBUG_REFCOUNT
- if (bp->dirtyp == NULL && bp != cm_data.buf_dirtyListEndp) {
- osi_Log1(afsd_logp,"buf_IncrSyncer bp 0x%p list corruption",bp);
- afsi_log("buf_IncrSyncer bp 0x%p list corruption", bp);
- }
+ if (bp->dirtyp == NULL && bp != cm_data.buf_dirtyListEndp) {
+ osi_Log1(afsd_logp,"buf_IncrSyncer bp 0x%p list corruption",bp);
+ afsi_log("buf_IncrSyncer bp 0x%p list corruption", bp);
+ }
#endif
- *bpp = bp->dirtyp;
- bp->dirtyp = NULL;
- bp->flags &= ~CM_BUF_INDL;
- if (cm_data.buf_dirtyListp == NULL)
- cm_data.buf_dirtyListEndp = NULL;
- else if (cm_data.buf_dirtyListEndp == bp)
- cm_data.buf_dirtyListEndp = prevbp;
- buf_ReleaseLocked(bp, TRUE);
- lock_ConvertWToR(&buf_globalLock);
- } else {
- /* advance the pointer so we don't loop forever */
- lock_ObtainRead(&buf_globalLock);
- bpp = &bp->dirtyp;
- prevbp = bp;
+ *bpp = bp->dirtyp;
+ bp->dirtyp = NULL;
+ bp->flags &= ~CM_BUF_INDL;
+ if (cm_data.buf_dirtyListp == NULL)
+ cm_data.buf_dirtyListEndp = NULL;
+ else if (cm_data.buf_dirtyListEndp == bp)
+ cm_data.buf_dirtyListEndp = prevbp;
+ buf_ReleaseLocked(bp, TRUE);
+ lock_ConvertWToR(&buf_globalLock);
+ } else {
+ if (buf_ShutdownFlag) {
+ cm_cell_t *cellp;
+ cm_volume_t *volp;
+ char volstr[VL_MAXNAMELEN+12]="";
+ char *ext = "";
+
+ volp = cm_GetVolumeByFID(&bp->fid);
+ if (volp) {
+ cellp = volp->cellp;
+ if (bp->fid.volume == volp->vol[RWVOL].ID)
+ ext = "";
+ else if (bp->fid.volume == volp->vol[ROVOL].ID)
+ ext = ".readonly";
+ else if (bp->fid.volume == volp->vol[BACKVOL].ID)
+ ext = ".backup";
+ else
+ ext = ".nomatch";
+ snprintf(volstr, sizeof(volstr), "%s%s", volp->namep, ext);
+ } else {
+ cellp = cm_FindCellByID(bp->fid.cell, CM_FLAG_NOPROBE);
+ snprintf(volstr, sizeof(volstr), "%u", bp->fid.volume);
+ }
+
+ LogEvent(EVENTLOG_INFORMATION_TYPE, MSG_DIRTY_BUFFER_AT_SHUTDOWN,
+ cellp->name, volstr, bp->fid.vnode, bp->fid.unique,
+ bp->offset.QuadPart+bp->dirty_offset, bp->dirty_length);
}
- lock_ReleaseMutex(&bp->mx);
- } /* for loop over a bunch of buffers */
- lock_ReleaseRead(&buf_globalLock);
- } /* whole daemon's while loop */
+
+ /* advance the pointer so we don't loop forever */
+ lock_ObtainRead(&buf_globalLock);
+ bpp = &bp->dirtyp;
+ prevbp = bp;
+ }
+ lock_ReleaseMutex(&bp->mx);
+ } /* for loop over a bunch of buffers */
+ lock_ReleaseRead(&buf_globalLock);
+
+ return wasDirty;
+}
+
+/* incremental sync daemon. Writes all dirty buffers every 5000 ms */
+void buf_IncrSyncer(long parm)
+{
+ long wasDirty = 0;
+ long i;
+
+ while (buf_ShutdownFlag == 0) {
+
+ if (!wasDirty) {
+ i = SleepEx(5000, 1);
+ if (i != 0)
+ continue;
+ } else {
+ Sleep(50);
+ }
+
+ wasDirty = buf_Sync(1);
+ } /* whole daemon's while loop */
}
long
}
void buf_Shutdown(void)
-{
+{
+ /* disable the buf_IncrSyncer() threads */
buf_ShutdownFlag = 1;
+
+ /* then force all dirty buffers to the file servers */
+ buf_Sync(0);
}
/* initialize the buffer package; called with no locks
if (osi_Once(&once)) {
/* initialize global locks */
- lock_InitializeRWLock(&buf_globalLock, "Global buffer lock");
+ lock_InitializeRWLock(&buf_globalLock, "Global buffer lock", LOCK_HIERARCHY_BUF_GLOBAL);
if ( newFile ) {
/* remember this for those who want to reset it */
osi_QAdd((osi_queue_t **)&cm_data.buf_freeListp, &bp->q);
bp->flags |= CM_BUF_INLRU;
- lock_InitializeMutex(&bp->mx, "Buffer mutex");
+ lock_InitializeMutex(&bp->mx, "Buffer mutex", LOCK_HIERARCHY_BUFFER);
/* grab appropriate number of bytes from aligned zone */
bp->datap = data;
data = cm_data.bufDataBaseAddress;
for (i=0; i<cm_data.buf_nbuffers; i++) {
- lock_InitializeMutex(&bp->mx, "Buffer mutex");
+ lock_InitializeMutex(&bp->mx, "Buffer mutex", LOCK_HIERARCHY_BUFFER);
bp->userp = NULL;
bp->waitCount = 0;
bp->waitRequests = 0;
return bp;
}
+/* find a buffer, if any, for a particular file ID and offset. Assumes
+ * that buf_globalLock is write locked when called. Uses the all buffer
+ * list.
+ */
+cm_buf_t *buf_FindAllLocked(struct cm_scache *scp, osi_hyper_t *offsetp, afs_uint32 flags)
+{
+ cm_buf_t *bp;
+
+ if (flags == 0) {
+ for(bp = cm_data.buf_allp; bp; bp=bp->allp) {
+ if (cm_FidCmp(&scp->fid, &bp->fid) == 0
+ && offsetp->LowPart == bp->offset.LowPart
+ && offsetp->HighPart == bp->offset.HighPart) {
+ buf_HoldLocked(bp);
+ break;
+ }
+ }
+ } else {
+ for(bp = cm_data.buf_allp; bp; bp=bp->allp) {
+ if (cm_FidCmp(&scp->fid, &bp->fid) == 0) {
+ char * fileOffset;
+
+ fileOffset = offsetp->QuadPart + cm_data.baseAddress;
+ if (fileOffset == bp->datap) {
+ buf_HoldLocked(bp);
+ break;
+ }
+ }
+ }
+ }
+ /* return whatever we found, if anything */
+ return bp;
+}
+
+/* find a buffer with offset *offsetp for vnode *scp. Called
+ * with no locks held. Use the all buffer list.
+ */
+cm_buf_t *buf_FindAll(struct cm_scache *scp, osi_hyper_t *offsetp, afs_uint32 flags)
+{
+ cm_buf_t *bp;
+
+ lock_ObtainRead(&buf_globalLock);
+ bp = buf_FindAllLocked(scp, offsetp, flags);
+ lock_ReleaseRead(&buf_globalLock);
+
+ return bp;
+}
+
/* start cleaning I/O on this buffer. Buffer must be write locked, and is returned
* write-locked.
*
*
* Returns non-zero if the buffer was dirty.
*/
-long buf_CleanAsyncLocked(cm_buf_t *bp, cm_req_t *reqp)
+afs_uint32 buf_CleanAsyncLocked(cm_buf_t *bp, cm_req_t *reqp, afs_uint32 *pisdirty)
{
- long code = 0;
- long isdirty = 0;
+ afs_uint32 code = 0;
+ afs_uint32 isdirty = 0;
cm_scache_t * scp = NULL;
osi_hyper_t offset;
bp->dirty_offset = 0;
bp->dirty_length = 0;
bp->error = code;
- bp->dataVersion = CM_BUF_VERSION_BAD; /* bad */
+ bp->dataVersion = CM_BUF_VERSION_BAD;
bp->dirtyCounter++;
break;
}
*/
if (reqp->flags & CM_REQ_NORETRY)
break;
- };
-
- if (!(bp->flags & CM_BUF_DIRTY)) {
- /* remove buffer from dirty buffer queue */
+ /* Ditto if the hardDeadTimeout or idleTimeout was reached */
+ if (code == CM_ERROR_TIMEDOUT || code == CM_ERROR_ALLDOWN ||
+ code == CM_ERROR_ALLBUSY || code == CM_ERROR_ALLOFFLINE ||
+ code == CM_ERROR_CLOCKSKEW) {
+ break;
+ }
}
- /* do logging after call to GetLastError, or else */
-
/* if someone was waiting for the I/O that just completed or failed,
* wake them up.
*/
osi_Log1(buf_logp, "buf_WaitIO Waking bp 0x%p", bp);
osi_Wakeup((LONG_PTR) bp);
}
- return isdirty;
+
+ if (pisdirty)
+ *pisdirty = isdirty;
+
+ return code;
}
/* Called with a zero-ref count buffer and with the buf_globalLock write locked.
* space from the buffer pool. In that case, the buffer will be returned
* without being hashed into the hash table.
*/
-long buf_GetNewLocked(struct cm_scache *scp, osi_hyper_t *offsetp, cm_buf_t **bufpp)
+long buf_GetNewLocked(struct cm_scache *scp, osi_hyper_t *offsetp, cm_req_t *reqp, cm_buf_t **bufpp)
{
cm_buf_t *bp; /* buffer we're dealing with */
cm_buf_t *nextBp; /* next buffer in file hash chain */
afs_uint32 i; /* temp */
- cm_req_t req;
-
- cm_InitReq(&req); /* just in case */
#ifdef TESTING
buf_ValidateBufQueues();
* have the WRITING flag set, so we won't get
* back here.
*/
- buf_CleanAsync(bp, &req);
+ buf_CleanAsync(bp, reqp, NULL);
/* now put it back and go around again */
buf_Release(bp);
osi_QRemove((osi_queue_t **) &cm_data.buf_freeListp, &bp->q);
bp->flags &= ~CM_BUF_INLRU;
+ /* prepare to return it. Give it a refcount */
+ bp->refCount = 1;
+#ifdef DEBUG_REFCOUNT
+ osi_Log2(afsd_logp,"buf_GetNewLocked bp 0x%p ref %d", bp, 1);
+ afsi_log("%s:%d buf_GetNewLocked bp 0x%p, ref %d", __FILE__, __LINE__, bp, 1);
+#endif
/* grab the mutex so that people don't use it
* before the caller fills it with data. Again, no one
* should have been able to get to this dude to lock it.
*/
if (!lock_TryMutex(&bp->mx)) {
osi_Log2(afsd_logp, "buf_GetNewLocked bp 0x%p cannot be mutex locked. refCount %d should be 0",
- bp, bp->refCount);
+ bp, bp->refCount);
osi_panic("buf_GetNewLocked: TryMutex failed",__FILE__,__LINE__);
}
- /* prepare to return it. Give it a refcount */
- bp->refCount = 1;
-#ifdef DEBUG_REFCOUNT
- osi_Log2(afsd_logp,"buf_GetNewLocked bp 0x%p ref %d", bp, 1);
- afsi_log("%s:%d buf_GetNewLocked bp 0x%p, ref %d", __FILE__, __LINE__, bp, 1);
-#endif
lock_ReleaseWrite(&buf_globalLock);
lock_ReleaseRead(&scp->bufCreateLock);
+
*bufpp = bp;
#ifdef TESTING
/* get a page, returning it held but unlocked. Doesn't fill in the page
* with I/O, since we're going to write the whole thing new.
*/
-long buf_GetNew(struct cm_scache *scp, osi_hyper_t *offsetp, cm_buf_t **bufpp)
+long buf_GetNew(struct cm_scache *scp, osi_hyper_t *offsetp, cm_req_t *reqp, cm_buf_t **bufpp)
{
cm_buf_t *bp;
long code;
}
/* otherwise, we have to create a page */
- code = buf_GetNewLocked(scp, &pageOffset, &bp);
+ code = buf_GetNewLocked(scp, &pageOffset, reqp, &bp);
/* check if the buffer was created in a race condition branch.
* If so, go around so we can hold a reference to it.
/* get a page, returning it held but unlocked. Make sure it is complete */
/* The scp must be unlocked when passed to this function */
-long buf_Get(struct cm_scache *scp, osi_hyper_t *offsetp, cm_buf_t **bufpp)
+long buf_Get(struct cm_scache *scp, osi_hyper_t *offsetp, cm_req_t *reqp, cm_buf_t **bufpp)
{
cm_buf_t *bp;
long code;
}
/* otherwise, we have to create a page */
- code = buf_GetNewLocked(scp, &pageOffset, &bp);
+ code = buf_GetNewLocked(scp, &pageOffset, reqp, &bp);
/* bp->mx is now held */
/* check if the buffer was created in a race condition branch.
}
/* clean a buffer synchronously */
-long buf_CleanAsync(cm_buf_t *bp, cm_req_t *reqp)
+afs_uint32 buf_CleanAsync(cm_buf_t *bp, cm_req_t *reqp, afs_uint32 *pisdirty)
{
long code;
osi_assertx(bp->magic == CM_BUF_MAGIC, "invalid cm_buf_t magic");
lock_ObtainMutex(&bp->mx);
- code = buf_CleanAsyncLocked(bp, reqp);
+ code = buf_CleanAsyncLocked(bp, reqp, pisdirty);
lock_ReleaseMutex(&bp->mx);
return code;
cm_InitReq(&req);
req.flags |= CM_REQ_NORETRY;
- buf_CleanAsync(bp, &req);
+ buf_CleanAsync(bp, &req, NULL);
buf_CleanWait(NULL, bp, FALSE);
/* relock and release buffer */
lock_ObtainMutex(&bp->mx);
/* start cleaning the buffer, and wait for it to finish */
- buf_CleanAsyncLocked(bp, reqp);
+ buf_CleanAsyncLocked(bp, reqp, NULL);
buf_WaitIO(scp, bp);
lock_ReleaseMutex(&bp->mx);
if (cm_FidCmp(&bp->fid, &scp->fid) == 0) {
lock_ObtainMutex(&bp->mx);
if (bp->flags & CM_BUF_DIRTY) {
- if (userp) {
+ if (userp && userp != bp->userp) {
cm_HoldUser(userp);
if (bp->userp)
cm_ReleaseUser(bp->userp);
bp->userp = userp;
}
- wasDirty = buf_CleanAsyncLocked(bp, reqp);
- buf_CleanWait(scp, bp, TRUE);
- if (bp->flags & CM_BUF_ERROR) {
- code = bp->error;
- if (code == 0)
- code = -1;
+
+ switch (code) {
+ case CM_ERROR_NOSUCHFILE:
+ case CM_ERROR_BADFD:
+ case CM_ERROR_NOACCESS:
+ case CM_ERROR_QUOTA:
+ case CM_ERROR_SPACE:
+ case CM_ERROR_TOOBIG:
+ case CM_ERROR_READONLY:
+ case CM_ERROR_NOSUCHPATH:
+ /*
+ * Apply the previous fatal error to this buffer.
+ * Do not waste the time attempting to store to
+ * the file server when we know it will fail.
+ */
+ bp->flags &= ~CM_BUF_DIRTY;
+ bp->flags |= CM_BUF_ERROR;
+ bp->dirty_offset = 0;
+ bp->dirty_length = 0;
+ bp->error = code;
+ bp->dataVersion = CM_BUF_VERSION_BAD;
+ bp->dirtyCounter++;
+ break;
+ case CM_ERROR_TIMEDOUT:
+ case CM_ERROR_ALLDOWN:
+ case CM_ERROR_ALLBUSY:
+ case CM_ERROR_ALLOFFLINE:
+ case CM_ERROR_CLOCKSKEW:
+ /* do not mark the buffer in error state but do
+ * not attempt to complete the rest either.
+ */
+ break;
+ default:
+ code = buf_CleanAsyncLocked(bp, reqp, &wasDirty);
+ if (bp->flags & CM_BUF_ERROR) {
+ code = bp->error;
+ if (code == 0)
+ code = -1;
+ }
}
+ buf_CleanWait(scp, bp, TRUE);
}
lock_ReleaseMutex(&bp->mx);
}
StringCbPrintfA(output, sizeof(output),
"%s bp=0x%08X, hash=%d, fid (cell=%d, volume=%d, "
"vnode=%d, unique=%d), offset=%x:%08x, dv=%I64d, "
- "flags=0x%x, cmFlags=0x%x, refCount=%d\r\n",
+ "flags=0x%x, cmFlags=0x%x, error=0x%x, refCount=%d\r\n",
cookie, (void *)bp, i, bp->fid.cell, bp->fid.volume,
bp->fid.vnode, bp->fid.unique, bp->offset.HighPart,
bp->offset.LowPart, bp->dataVersion, bp->flags,
- bp->cmFlags, bp->refCount);
+ bp->cmFlags, bp->error, bp->refCount);
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
}
}
StringCbPrintfA(output, sizeof(output),
"%s bp=0x%08X, fid (cell=%d, volume=%d, "
"vnode=%d, unique=%d), offset=%x:%08x, dv=%I64d, "
- "flags=0x%x, cmFlags=0x%x, refCount=%d\r\n",
+ "flags=0x%x, cmFlags=0x%x, error=0x%x, refCount=%d\r\n",
cookie, (void *)bp, bp->fid.cell, bp->fid.volume,
bp->fid.vnode, bp->fid.unique, bp->offset.HighPart,
bp->offset.LowPart, bp->dataVersion, bp->flags,
- bp->cmFlags, bp->refCount);
+ bp->cmFlags, bp->error, bp->refCount);
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
}
StringCbPrintfA(output, sizeof(output), "%s - Done dumping buf_FreeListEndp.\r\n", cookie);
StringCbPrintfA(output, sizeof(output),
"%s bp=0x%08X, fid (cell=%d, volume=%d, "
"vnode=%d, unique=%d), offset=%x:%08x, dv=%I64d, "
- "flags=0x%x, cmFlags=0x%x, refCount=%d\r\n",
+ "flags=0x%x, cmFlags=0x%x, error=0x%x, refCount=%d\r\n",
cookie, (void *)bp, bp->fid.cell, bp->fid.volume,
bp->fid.vnode, bp->fid.unique, bp->offset.HighPart,
bp->offset.LowPart, bp->dataVersion, bp->flags,
- bp->cmFlags, bp->refCount);
+ bp->cmFlags, bp->error, bp->refCount);
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
}
StringCbPrintfA(output, sizeof(output), "%s - Done dumping buf_dirtyListp.\r\n", cookie);