/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
- *
+ *
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
static int
-afs_StoreMini(register struct vcache *avc, struct vrequest *areq)
+afs_StoreMini(struct vcache *avc, struct vrequest *areq)
{
- register struct afs_conn *tc;
+ struct afs_conn *tc;
struct AFSStoreStatus InStatus;
struct AFSFetchStatus OutStatus;
struct AFSVolSync tsync;
- register afs_int32 code, code2;
- register struct rx_call *tcall;
+ afs_int32 code;
+ struct rx_call *tcall;
+ struct rx_connection *rxconn;
afs_size_t tlen, xlen = 0;
XSTATS_DECLS;
AFS_STATCNT(afs_StoreMini);
tlen = avc->f.truncPos;
avc->f.truncPos = AFS_NOTRUNC;
avc->f.states &= ~CExtendedFile;
+ memset(&InStatus, 0, sizeof(InStatus));
do {
- tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
+ tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
#ifdef AFS_64BIT_CLIENT
retry:
#endif
RX_AFS_GUNLOCK();
- tcall = rx_NewCall(tc->id);
+ tcall = rx_NewCall(rxconn);
RX_AFS_GLOCK();
/* Set the client mod time since we always want the file
* to have the client's mod time and not the server's one
if ((avc->f.m.Length > 0x7fffffff) ||
(tlen > 0x7fffffff) ||
((0x7fffffff - tlen) < avc->f.m.Length)) {
- RX_AFS_GLOCK();
- return EFBIG;
+ code = EFBIG;
+ goto error;
}
code =
StartRXAFS_StoreData(tcall,
if (code == 0) {
code = EndRXAFS_StoreData(tcall, &OutStatus, &tsync);
}
- code2 = rx_EndCall(tcall, code);
- if (code2 && !code)
- code = code2;
+#ifdef AFS_64BIT_CLIENT
+ error:
+#endif
+ code = rx_EndCall(tcall, code);
RX_AFS_GLOCK();
XSTATS_END_TIME;
#ifdef AFS_64BIT_CLIENT
} else
code = -1;
} while (afs_Analyze
- (tc, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_STOREDATA,
+ (tc, rxconn, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_STOREDATA,
SHARED_LOCK, NULL));
if (code == 0)
int
-afs_StoreAllSegments(register struct vcache *avc, struct vrequest *areq,
+afs_StoreAllSegments(struct vcache *avc, struct vrequest *areq,
int sync)
{
- register struct dcache *tdc;
- register afs_int32 code = 0;
- register afs_int32 index;
- register afs_int32 origCBs, foreign = 0;
+ struct dcache *tdc;
+ afs_int32 code = 0;
+ afs_int32 index;
+ afs_int32 origCBs, foreign = 0;
int hash;
afs_hyper_t newDV, oldDV; /* DV when we start, and finish, respectively */
struct dcache **dcList;
unsigned int i, j, minj, moredata, high, off;
- afs_size_t tlen;
afs_size_t maxStoredLength; /* highest offset we've written to server. */
int safety, marineronce = 0;
AFS_STATCNT(afs_StoreAllSegments);
- hset(oldDV, avc->f.m.DataVersion);
- hset(newDV, avc->f.m.DataVersion);
hash = DVHash(&avc->f.fid);
foreign = (avc->f.states & CForeign);
- dcList = (struct dcache **)osi_AllocLargeSpace(AFS_LRALLOCSIZ);
+ dcList = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
afs_Trace2(afs_iclSetp, CM_TRACE_STOREALL, ICL_TYPE_POINTER, avc,
ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length));
#if !defined(AFS_AIX32_ENV) && !defined(AFS_SGI65_ENV)
* on the memcache case since that's we adjust the file's size
* and finish flushing partial vm pages.
*/
- if ((cacheDiskType != AFS_FCACHE_TYPE_MEM) || (sync & AFS_LASTSTORE))
+ if ((cacheDiskType != AFS_FCACHE_TYPE_MEM) ||
+ (sync & AFS_VMSYNC_INVAL) || (sync & AFS_VMSYNC) ||
+ (sync & AFS_LASTSTORE))
#endif /* !AFS_AIX32_ENV && !AFS_SGI65_ENV */
{
/* If we're not diskless, reading a file may stress the VM
/*printf("Net down in afs_StoreSegments\n");*/
return ENETDOWN;
}
+
+ /*
+ * Can't do this earlier because osi_VM_StoreAllSegments drops locks
+ * and can indirectly do some stores that increase the DV.
+ */
+ hset(oldDV, avc->f.m.DataVersion);
+ hset(newDV, avc->f.m.DataVersion);
+
ConvertWToSLock(&avc->lock);
/*
* - Have to get a write lock on xdcache because GetDSlot might need it (if
* the chunk doesn't have a dcache struct).
* This seems like overkill in most cases.
- * - I'm not sure that it's safe to do "index = .hvNextp", then unlock
+ * - I'm not sure that it's safe to do "index = .hvNextp", then unlock
* xdcache, then relock xdcache and try to use index. It is done
* a lot elsewhere in the CM, but I'm not buying that argument.
* - should be able to check IFDataMod without doing the GetDSlot (just
* hold afs_xdcache). That way, it's easy to do this without the
* writelock on afs_xdcache, and we save unneccessary disk
- * operations. I don't think that works, 'cuz the next pointers
+ * operations. I don't think that works, 'cuz the next pointers
* are still on disk.
*/
origCBs = afs_allCBs;
maxStoredLength = 0;
- tlen = avc->f.m.Length;
minj = 0;
do {
high = 0;
moredata = FALSE;
- /* lock and start over from beginning of hash chain
+ /* lock and start over from beginning of hash chain
* in order to avoid a race condition. */
ObtainWriteLock(&afs_xdcache, 284);
index = afs_dvhashTbl[hash];
for (j = 0; index != NULLIDX;) {
if ((afs_indexFlags[index] & IFDataMod)
&& (afs_indexUnique[index] == avc->f.fid.Fid.Unique)) {
- tdc = afs_GetDSlot(index, 0); /* refcount+1. */
+ tdc = afs_GetValidDSlot(index); /* refcount+1. */
+ if (!tdc) {
+ ReleaseWriteLock(&afs_xdcache);
+ code = EIO;
+ goto done;
+ }
ReleaseReadLock(&tdc->tlock);
if (!FidCmp(&tdc->f.fid, &avc->f.fid) && tdc->f.chunk >= minj) {
off = tdc->f.chunk - minj;
minj += NCHUNKSATONCE;
} while (!code && moredata);
+ done:
UpgradeSToWLock(&avc->lock, 29);
/* send a trivial truncation store if did nothing else */
* Call StoreMini if we haven't written enough data to extend the
* file at the fileserver to the client's notion of the file length.
*/
- if ((avc->f.truncPos != AFS_NOTRUNC)
+ if ((avc->f.truncPos != AFS_NOTRUNC)
|| ((avc->f.states & CExtendedFile)
&& (maxStoredLength < avc->f.m.Length))) {
code = afs_StoreMini(avc, areq);
/*
* Finally, turn off DWriting, turn on DFEntryMod,
* update f.versionNo.
- * A lot of this could be integrated into the loop above
+ * A lot of this could be integrated into the loop above
*/
if (!code) {
afs_hyper_t h_unset;
ObtainWriteLock(&afs_xdcache, 285);
for (j = 0, safety = 0, index = afs_dvhashTbl[hash];
- index != NULLIDX && safety < afs_cacheFiles + 2;) {
+ index != NULLIDX && safety < afs_cacheFiles + 2;
+ index = afs_dvnextTbl[index]) {
if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
- tdc = afs_GetDSlot(index, 0);
+ tdc = afs_GetValidDSlot(index);
+ if (!tdc) {
+ /* This is okay; since manipulating the dcaches at this
+ * point is best-effort. We only get a dcache here to
+ * increment the dv and turn off DWriting. If we were
+ * supposed to do that for a dcache, but could not
+ * due to an I/O error, it just means the dv won't
+ * be updated so we don't be able to use that cached
+ * chunk in the future. That's inefficient, but not
+ * an error. */
+ break;
+ }
ReleaseReadLock(&tdc->tlock);
if (!FidCmp(&tdc->f.fid, &avc->f.fid)
afs_PutDCache(tdc);
}
}
-
- index = afs_dvnextTbl[index];
}
ReleaseWriteLock(&afs_xdcache);
UpgradeSToWLock(&tdc->lock, 678);
hset(tdc->f.versionNo, avc->f.m.DataVersion);
tdc->dflags |= DFEntryMod;
+ /* DWriting may not have gotten cleared above, if all
+ * we did was a StoreMini */
+ tdc->f.states &= ~DWriting;
ConvertWToSLock(&tdc->lock);
}
}
} /*afs_StoreAllSegments (new 03/02/94) */
-
-/*
- * afs_InvalidateAllSegments
- *
- * Description:
- * Invalidates all chunks for a given file
- *
- * Parameters:
- * avc : Pointer to vcache entry.
- *
- * Environment:
- * For example, called after an error has been detected. Called
- * with avc write-locked, and afs_xdcache unheld.
- */
-
int
-afs_InvalidateAllSegments(struct vcache *avc)
+afs_InvalidateAllSegments_once(struct vcache *avc)
{
struct dcache *tdc;
afs_int32 hash;
afs_int32 index;
- struct dcache **dcList;
- int i, dcListMax, dcListCount;
+ struct dcache **dcList = NULL;
+ int i, dcListMax, dcListCount = 0;
AFS_STATCNT(afs_InvalidateAllSegments);
afs_Trace2(afs_iclSetp, CM_TRACE_INVALL, ICL_TYPE_POINTER, avc,
hash = DVHash(&avc->f.fid);
avc->f.truncPos = AFS_NOTRUNC; /* don't truncate later */
avc->f.states &= ~CExtendedFile; /* not any more */
- ObtainWriteLock(&afs_xcbhash, 459);
- afs_DequeueCallback(avc);
- avc->f.states &= ~(CStatd | CDirty); /* mark status information as bad, too */
- ReleaseWriteLock(&afs_xcbhash);
- if (avc->f.fid.Fid.Vnode & 1 || (vType(avc) == VDIR))
- osi_dnlc_purgedp(avc);
+ afs_StaleVCacheFlags(avc, 0, CDirty);
/* Blow away pages; for now, only for Solaris */
#if (defined(AFS_SUN5_ENV))
if (WriteLocked(&avc->lock))
for (index = afs_dvhashTbl[hash]; index != NULLIDX;) {
if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
- tdc = afs_GetDSlot(index, 0);
+ tdc = afs_GetValidDSlot(index);
+ if (!tdc) {
+ goto error;
+ }
ReleaseReadLock(&tdc->tlock);
if (!FidCmp(&tdc->f.fid, &avc->f.fid))
dcListMax++;
}
dcList = osi_Alloc(dcListMax * sizeof(struct dcache *));
- dcListCount = 0;
for (index = afs_dvhashTbl[hash]; index != NULLIDX;) {
if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
- tdc = afs_GetDSlot(index, 0);
+ tdc = afs_GetValidDSlot(index);
+ if (!tdc) {
+ goto error;
+ }
ReleaseReadLock(&tdc->tlock);
if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
/* same file? we'll zap it */
osi_Free(dcList, dcListMax * sizeof(struct dcache *));
return 0;
+
+ error:
+ ReleaseWriteLock(&afs_xdcache);
+
+ if (dcList) {
+ for (i = 0; i < dcListCount; i++) {
+ tdc = dcList[i];
+ if (tdc) {
+ afs_PutDCache(tdc);
+ }
+ }
+ osi_Free(dcList, dcListMax * sizeof(struct dcache *));
+ }
+ return EIO;
}
-/*!
- *
+
+/*
+ * afs_InvalidateAllSegments
+ *
+ * Description:
+ * Invalidates all chunks for a given file
+ *
+ * Parameters:
+ * avc : Pointer to vcache entry.
+ *
+ * Environment:
+ * For example, called after an error has been detected. Called
+ * with avc write-locked, and afs_xdcache unheld.
+ */
+
+void
+afs_InvalidateAllSegments(struct vcache *avc)
+{
+ int code;
+ afs_uint32 last_warn;
+
+ code = afs_InvalidateAllSegments_once(avc);
+ if (code == 0) {
+ /* Success; nothing more to do. */
+ return;
+ }
+
+ /*
+ * If afs_InvalidateAllSegments_once failed, we cannot simply return an
+ * error to our caller. This function is called when we encounter a fatal
+ * error during stores, in which case we MUST invalidate all chunks for the
+ * given file. If we fail to invalidate some chunks, they will be left with
+ * the 'new' dirty/written data that was never successfully stored on the
+ * server, but the DV in the dcache is still the old DV. So, if its left
+ * alone, we may indefinitely serve data to applications that is not
+ * actually in the file on the fileserver.
+ *
+ * So to make sure we never serve userspace bad data after such a failure,
+ * we must keep trying to invalidate the dcaches for the given file. (Note
+ * that we cannot simply set a flag on the vcache to retry the invalidate
+ * later on, because the vcache may go away, but the 'bad' dcaches could
+ * remain.) We do this below, via background daemon requests because in
+ * some scenarios we can always get I/O errors on accessing the cache if we
+ * access via a user pid. (e.g. on LINUX, this can happen if the pid has a
+ * pending SIGKILL.) Doing this via background daemon ops should avoid
+ * that.
+ */
+
+ last_warn = osi_Time();
+ afs_warn("afs: Failed to invalidate cache chunks for fid %d.%d.%d.%d; our "
+ "local disk cache may be throwing errors. We must invalidate "
+ "these chunks to avoid possibly serving incorrect data, so we'll "
+ "retry until we succeed. If AFS access seems to hang, this may "
+ "be why.\n",
+ avc->f.fid.Cell, avc->f.fid.Fid.Volume, avc->f.fid.Fid.Vnode,
+ avc->f.fid.Fid.Unique);
+
+ do {
+ static const afs_uint32 warn_int = 60*60; /* warn once every hour */
+ afs_uint32 now = osi_Time();
+ struct brequest *bp;
+
+ if (now < last_warn || now - last_warn > warn_int) {
+ last_warn = now;
+ afs_warn("afs: Still trying to invalidate cache chunks for fid "
+ "%d.%d.%d.%d. We will retry until we succeed; if AFS "
+ "access seems to hang, this may be why.\n",
+ avc->f.fid.Cell, avc->f.fid.Fid.Volume,
+ avc->f.fid.Fid.Vnode, avc->f.fid.Fid.Unique);
+ }
+
+ /* Wait 10 seconds between attempts. */
+ afs_osi_Wait(1000 * 10, NULL, 0);
+
+ /*
+ * Ask a background daemon to do this request for us. Note that _we_ hold
+ * the write lock on 'avc', while the background daemon does the work. This
+ * is a little weird, but it helps avoid any issues with lock ordering
+ * or if our caller does not expect avc->lock to be dropped while
+ * running.
+ */
+ bp = afs_BQueue(BOP_INVALIDATE_SEGMENTS, avc, 0, 1, NULL, 0, 0, NULL,
+ NULL, NULL);
+ while ((bp->flags & BUVALID) == 0) {
+ bp->flags |= BUWAIT;
+ afs_osi_Sleep(bp);
+ }
+ code = bp->code_raw;
+ afs_BRelease(bp);
+ } while (code);
+}
+
+/*!
+ *
* Extend a cache file
*
* \param avc pointer to vcache to extend data for
struct dcache *tdc;
void *zeros;
- zeros = (void *) afs_osi_Alloc(AFS_PAGESIZE);
+ zeros = afs_osi_Alloc(AFS_PAGESIZE);
if (zeros == NULL)
return ENOMEM;
memset(zeros, 0, AFS_PAGESIZE);
toAdd = AFS_CHUNKTOSIZE(tdc->f.chunk) - offset;
}
tfile = afs_CFileOpen(&tdc->f.inode);
+ if (!tfile) {
+ ReleaseWriteLock(&tdc->lock);
+ afs_PutDCache(tdc);
+ code = EIO;
+ break;
+ }
while(tdc->validPos < avc->f.m.Length + toAdd) {
afs_size_t towrite;
towrite = (avc->f.m.Length + toAdd) - tdc->validPos;
if (towrite > AFS_PAGESIZE) towrite = AFS_PAGESIZE;
- code = afs_CFileWrite(tfile,
- tdc->validPos - AFS_CHUNKTOBASE(tdc->f.chunk),
+ code = afs_CFileWrite(tfile,
+ tdc->validPos - AFS_CHUNKTOBASE(tdc->f.chunk),
zeros, towrite);
tdc->validPos += towrite;
}
* held.
*/
int
-afs_TruncateAllSegments(register struct vcache *avc, afs_size_t alen,
+afs_TruncateAllSegments(struct vcache *avc, afs_size_t alen,
struct vrequest *areq, afs_ucred_t *acred)
{
- register struct dcache *tdc;
- register afs_int32 code;
- register afs_int32 index;
+ struct dcache *tdc;
+ afs_int32 code;
+ afs_int32 index;
afs_size_t newSize;
int dcCount, dcPos;
- struct dcache **tdcArray;
+ struct dcache **tdcArray = NULL;
AFS_STATCNT(afs_TruncateAllSegments);
avc->f.m.Date = osi_Time();
dcCount = 0;
for (index = afs_dvhashTbl[code]; index != NULLIDX;) {
if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
- tdc = afs_GetDSlot(index, 0);
+ tdc = afs_GetValidDSlot(index);
+ if (!tdc) {
+ ReleaseWriteLock(&afs_xdcache);
+ code = EIO;
+ goto done;
+ }
ReleaseReadLock(&tdc->tlock);
if (!FidCmp(&tdc->f.fid, &avc->f.fid))
dcCount++;
tdcArray = osi_Alloc(dcCount * sizeof(struct dcache *));
dcPos = 0;
- for (index = afs_dvhashTbl[code]; index != NULLIDX;) {
+ for (index = afs_dvhashTbl[code]; index != NULLIDX; index = afs_dvnextTbl[index]) {
if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
- tdc = afs_GetDSlot(index, 0);
+ tdc = afs_GetValidDSlot(index);
+ if (!tdc) {
+ /* make sure we put back all of the tdcArray members before
+ * bailing out */
+ /* remember, the last valid tdc is at dcPos-1, so start at
+ * dcPos-1, not at dcPos itself. */
+ for (dcPos = dcPos - 1; dcPos >= 0; dcPos--) {
+ tdc = tdcArray[dcPos];
+ afs_PutDCache(tdc);
+ }
+ code = EIO;
+ goto done;
+ }
ReleaseReadLock(&tdc->tlock);
if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
/* same file, and modified, we'll store it back */
afs_PutDCache(tdc);
}
}
- index = afs_dvnextTbl[index];
}
ReleaseWriteLock(&afs_xdcache);
ObtainSharedLock(&tdc->lock, 672);
if (newSize < tdc->f.chunkBytes && newSize < MAX_AFS_UINT32) {
UpgradeSToWLock(&tdc->lock, 673);
+ tdc->f.states |= DWriting;
tfile = afs_CFileOpen(&tdc->f.inode);
+ osi_Assert(tfile);
afs_CFileTruncate(tfile, (afs_int32)newSize);
afs_CFileClose(tfile);
afs_AdjustSize(tdc, (afs_int32)newSize);
afs_PutDCache(tdc);
}
- osi_Free(tdcArray, dcCount * sizeof(struct dcache *));
+ code = 0;
+ done:
+ if (tdcArray) {
+ osi_Free(tdcArray, dcCount * sizeof(struct dcache *));
+ }
#if (defined(AFS_SUN5_ENV))
ObtainWriteLock(&avc->vlock, 547);
if (--avc->activeV == 0 && (avc->vstates & VRevokeWait)) {
ReleaseWriteLock(&avc->vlock);
#endif
- return 0;
+ return code;
}
git://git.openafs.org / openafs.git / blobdiff