osi_assertx(userp != NULL, "null cm_user_t");
osi_assertx(scp != NULL, "null cm_scache_t");
+ memset(&volSync, 0, sizeof(volSync));
+
/* now, the buffer may or may not be filled with good data (buf_GetNew
* drops lots of locks, and may indeed return a properly initialized
* buffer, although more likely it will just return a new, empty, buffer.
temp = rx_Write(rxcallp, bufferp, wbytes);
if (temp != wbytes) {
osi_Log3(afsd_logp, "rx_Write failed bp 0x%p, %d != %d",bufp,temp,wbytes);
- code = -1;
+ code = (rxcallp->error < 0) ? rxcallp->error : RX_PROTOCOL_ERROR;
break;
} else {
osi_Log2(afsd_logp, "rx_Write succeeded bp 0x%p, %d",bufp,temp);
int require_64bit_ops = 0;
int call_was_64bit = 0;
+ memset(&volSync, 0, sizeof(volSync));
+
/* Serialize StoreData RPC's; for rationale see cm_scache.c */
(void) cm_SyncOp(scp, NULL, userp, reqp, 0,
CM_SCACHESYNC_STOREDATA_EXCL);
long cm_BufRead(cm_buf_t *bufp, long nbytes, long *bytesReadp, cm_user_t *userp)
{
- *bytesReadp = cm_data.buf_blockSize;
+ *bytesReadp = 0;
/* now return a code that means that I/O is done */
return 0;
return 1;
if (bufp->dataVersion <= scp->dataVersion && bufp->dataVersion >= scp->bufDataVersionLow)
return 1;
+ if (bufp->offset.QuadPart >= scp->serverLength.QuadPart)
+ return 1;
if (!isBufLocked) {
code = lock_TryMutex(&bufp->mx);
if (code == 0) {
return 0;
}
-/* used when deciding whether to do a prefetch or not */
-long cm_CheckFetchRange(cm_scache_t *scp, osi_hyper_t *startBasep, osi_hyper_t *length,
+/*
+ * used when deciding whether to do a background fetch or not.
+ * call with scp->rw write-locked.
+ */
+afs_int32
+cm_CheckFetchRange(cm_scache_t *scp, osi_hyper_t *startBasep, osi_hyper_t *length,
cm_user_t *userp, cm_req_t *reqp, osi_hyper_t *realBasep)
{
osi_hyper_t tbase;
tlength = *length;
tblocksize = ConvertLongToLargeInteger(cm_data.buf_blockSize);
stop = 0;
- lock_ObtainWrite(&scp->rw);
while (LargeIntegerGreaterThanZero(tlength)) {
/* get callback so we can do a meaningful dataVersion comparison */
code = cm_SyncOp(scp, NULL, userp, reqp, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- if (code) {
- scp->flags &= ~CM_SCACHEFLAG_PREFETCHING;
- lock_ReleaseWrite(&scp->rw);
+ if (code)
return code;
- }
if (LargeIntegerGreaterThanOrEqualTo(tbase, scp->length)) {
/* we're past the end of file */
bp = buf_Find(scp, &tbase);
/* We cheat slightly by not locking the bp mutex. */
if (bp) {
- if ((bp->cmFlags & (CM_BUF_CMFETCHING | CM_BUF_CMSTORING)) == 0
+ if ((bp->cmFlags & (CM_BUF_CMFETCHING | CM_BUF_CMSTORING | CM_BUF_CMBKGFETCH)) == 0
&& (bp->dataVersion < scp->bufDataVersionLow || bp->dataVersion > scp->dataVersion))
stop = 1;
buf_Release(bp);
*/
if (stop == 0) {
/* return non-zero code since realBasep won't be valid */
- scp->flags &= ~CM_SCACHEFLAG_PREFETCHING;
code = -1;
}
else {
*realBasep = tbase;
code = 0;
}
- lock_ReleaseWrite(&scp->rw);
return code;
}
osi_hyper_t end;
osi_hyper_t fetched;
osi_hyper_t tblocksize;
- long code;
- int mxheld = 0;
+ afs_int32 code;
+ int rxheld = 0;
cm_buf_t *bp = NULL;
cm_req_t req;
end = LargeIntegerAdd(base, length);
- osi_Log3(afsd_logp, "Starting BKG prefetch scp 0x%p, base 0x%x:%x", scp, p2, p1);
+ osi_Log5(afsd_logp, "Starting BKG prefetch scp 0x%p offset 0x%x:%x length 0x%x:%x",
+ scp, p2, p1, p4, p3);
for ( code = 0, offset = base;
code == 0 && LargeIntegerLessThan(offset, end);
offset = LargeIntegerAdd(offset, tblocksize) )
{
- if (mxheld) {
+ if (rxheld) {
lock_ReleaseWrite(&scp->rw);
- mxheld = 0;
+ rxheld = 0;
}
code = buf_Get(scp, &offset, &req, &bp);
if (bp->cmFlags & CM_BUF_CMFETCHING) {
/* skip this buffer as another thread is already fetching it */
+ if (!rxheld) {
+ lock_ObtainWrite(&scp->rw);
+ rxheld = 1;
+ }
+ bp->cmFlags &= ~CM_BUF_CMBKGFETCH;
buf_Release(bp);
bp = NULL;
continue;
}
- if (!mxheld) {
+ if (!rxheld) {
lock_ObtainWrite(&scp->rw);
- mxheld = 1;
+ rxheld = 1;
}
code = cm_GetBuffer(scp, bp, NULL, userp, &req);
if (code == 0)
fetched = LargeIntegerAdd(fetched, tblocksize);
buf_Release(bp);
+ bp->cmFlags &= ~CM_BUF_CMBKGFETCH;
}
- if (!mxheld) {
+ if (!rxheld) {
lock_ObtainWrite(&scp->rw);
- mxheld = 1;
+ rxheld = 1;
+ }
+
+ /* Clear flag from any remaining buffers */
+ for ( ;
+ LargeIntegerLessThan(offset, end);
+ offset = LargeIntegerAdd(offset, tblocksize) )
+ {
+ bp = buf_Find(scp, &offset);
+ if (bp) {
+ bp->cmFlags &= ~CM_BUF_CMBKGFETCH;
+ buf_Release(bp);
+ }
}
cm_ClearPrefetchFlag(LargeIntegerGreaterThanZero(fetched) ? 0 : code,
scp, &base, &fetched);
+
+ /* wakeup anyone who is waiting */
+ if (scp->flags & CM_SCACHEFLAG_WAITING) {
+ osi_Log1(afsd_logp, "CM BkgPrefetch Waking scp 0x%p", scp);
+ osi_Wakeup((LONG_PTR) &scp->flags);
+ }
lock_ReleaseWrite(&scp->rw);
- osi_Log4(afsd_logp, "Ending BKG prefetch scp 0x%p, code %d bytes 0x%x:%x",
- scp, code, fetched.HighPart, fetched.LowPart);
+ osi_Log4(afsd_logp, "Ending BKG prefetch scp 0x%p code 0x%x fetched 0x%x:%x",
+ scp, code, fetched.HighPart, fetched.LowPart);
return code;
}
cm_user_t *userp, cm_req_t *reqp)
{
long code;
+ int rwheld = 0;
osi_hyper_t realBase;
osi_hyper_t readBase;
osi_hyper_t readLength;
+ osi_hyper_t readEnd;
+ osi_hyper_t offset;
+ osi_hyper_t tblocksize; /* a long long temp variable */
+ cm_buf_t *bp;
+
+ tblocksize = ConvertLongToLargeInteger(cm_data.buf_blockSize);
readBase = *offsetp;
/* round up to chunk boundary */
readLength = ConvertLongToLargeInteger(count);
lock_ObtainWrite(&scp->rw);
+ rwheld = 1;
if ((scp->flags & CM_SCACHEFLAG_PREFETCHING)
|| LargeIntegerLessThanOrEqualTo(readBase, scp->prefetch.base)) {
lock_ReleaseWrite(&scp->rw);
if (LargeIntegerGreaterThan(scp->prefetch.end, readBase))
readBase = scp->prefetch.end;
- lock_ReleaseWrite(&scp->rw);
-
code = cm_CheckFetchRange(scp, &readBase, &readLength, userp, reqp,
&realBase);
- if (code)
+ if (code) {
+ scp->flags &= ~CM_SCACHEFLAG_PREFETCHING;
+ lock_ReleaseWrite(&scp->rw);
return; /* can't find something to prefetch */
+ }
+
+ readEnd = LargeIntegerAdd(realBase, readLength);
+
+ /*
+ * Mark each buffer in the range as queued for a
+ * background fetch
+ */
+ for ( offset = realBase;
+ LargeIntegerLessThan(offset, readEnd);
+ offset = LargeIntegerAdd(offset, tblocksize) )
+ {
+ if (rwheld) {
+ lock_ReleaseWrite(&scp->rw);
+ rwheld = 0;
+ }
+
+ bp = buf_Find(scp, &offset);
+ if (!bp)
+ continue;
+
+ if (!rwheld) {
+ lock_ObtainWrite(&scp->rw);
+ rwheld = 1;
+ }
+
+ bp->cmFlags |= CM_BUF_CMBKGFETCH;
+ buf_Release(bp);
+ }
+
+ if (rwheld)
+ lock_ReleaseWrite(&scp->rw);
osi_Log2(afsd_logp, "BKG Prefetch request scp 0x%p, base 0x%x",
scp, realBase.LowPart);
/* get buffer mutex and scp mutex safely */
lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&bufp->mx);
- lock_ObtainWrite(&scp->rw);
+ /*
+ * if the buffer is actively involved in I/O
+ * we wait for the I/O to complete.
+ */
+ if (bufp->flags & (CM_BUF_WRITING|CM_BUF_READING))
+ buf_WaitIO(scp, bufp);
+
+ lock_ObtainWrite(&scp->rw);
flags = CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_STOREDATA | CM_SCACHESYNC_BUFLOCKED;
code = cm_SyncOp(scp, bufp, userp, reqp, 0, flags);
if (code) {
biop->bufListEndp = NULL;
}
+static int
+cm_CloneStatus(cm_scache_t *scp, cm_user_t *userp, int scp_locked,
+ AFSFetchStatus *afsStatusp, AFSVolSync *volSyncp)
+{
+ // setup the status based upon the scp data
+ afsStatusp->InterfaceVersion = 0x1;
+ switch (scp->fileType) {
+ case CM_SCACHETYPE_FILE:
+ afsStatusp->FileType = File;
+ break;
+ case CM_SCACHETYPE_DIRECTORY:
+ afsStatusp->FileType = Directory;
+ break;
+ case CM_SCACHETYPE_MOUNTPOINT:
+ afsStatusp->FileType = SymbolicLink;
+ break;
+ case CM_SCACHETYPE_SYMLINK:
+ case CM_SCACHETYPE_DFSLINK:
+ afsStatusp->FileType = SymbolicLink;
+ break;
+ default:
+ afsStatusp->FileType = -1; /* an invalid value */
+ }
+ afsStatusp->LinkCount = scp->linkCount;
+ afsStatusp->Length = scp->length.LowPart;
+ afsStatusp->DataVersion = (afs_uint32)(scp->dataVersion & MAX_AFS_UINT32);
+ afsStatusp->Author = 0x1;
+ afsStatusp->Owner = scp->owner;
+ if (!scp_locked) {
+ lock_ObtainWrite(&scp->rw);
+ scp_locked = 1;
+ }
+ if (cm_FindACLCache(scp, userp, &afsStatusp->CallerAccess))
+ afsStatusp->CallerAccess = scp->anyAccess;
+ afsStatusp->AnonymousAccess = scp->anyAccess;
+ afsStatusp->UnixModeBits = scp->unixModeBits;
+ afsStatusp->ParentVnode = scp->parentVnode;
+ afsStatusp->ParentUnique = scp->parentUnique;
+ afsStatusp->ResidencyMask = 0;
+ afsStatusp->ClientModTime = scp->clientModTime;
+ afsStatusp->ServerModTime = scp->serverModTime;
+ afsStatusp->Group = scp->group;
+ afsStatusp->SyncCounter = 0;
+ afsStatusp->dataVersionHigh = (afs_uint32)(scp->dataVersion >> 32);
+ afsStatusp->lockCount = 0;
+ afsStatusp->Length_hi = scp->length.HighPart;
+ afsStatusp->errorCode = 0;
+
+ volSyncp->spare1 = scp->volumeCreationDate;
+
+ return scp_locked;
+}
+
/* Fetch a buffer. Called with scp locked.
* The scp is locked on return.
*/
long cm_GetBuffer(cm_scache_t *scp, cm_buf_t *bufp, int *cpffp, cm_user_t *userp,
cm_req_t *reqp)
{
- long code, code1;
+ long code=0, code1=0;
afs_uint32 nbytes; /* bytes in transfer */
afs_uint32 nbytes_hi = 0; /* high-order 32 bits of bytes in transfer */
afs_uint64 length_found = 0;
afs_int32 t1,t2;
int require_64bit_ops = 0;
int call_was_64bit = 0;
+ int fs_fetchdata_offset_bug = 0;
+ int first_read = 1;
+ int scp_locked = 1;
+
+ memset(&volSync, 0, sizeof(volSync));
/* now, the buffer may or may not be filled with good data (buf_GetNew
* drops lots of locks, and may indeed return a properly initialized
}
lock_ReleaseWrite(&scp->rw);
+ scp_locked = 0;
if (LargeIntegerGreaterThan(LargeIntegerAdd(biod.offset,
ConvertLongToLargeInteger(biod.length)),
afsStatus.lockCount = 0;
afsStatus.Length_hi = 0;
afsStatus.errorCode = 0;
-
+ memset(&volSync, 0, sizeof(volSync));
+
// once we're done setting up the status info,
// we just fill the buffer pages with fakedata
// from cm_FakeRootDir. Extra pages are set to
#endif /* AFS_FREELANCE_CLIENT */
- /* now make the call */
+ /*
+ * if the requested offset is greater than the file length,
+ * the file server will return zero bytes of data and the
+ * current status for the file which we already have since
+ * we have just obtained a callback. Instead, we can avoid
+ * the network round trip by allocating zeroed buffers and
+ * faking the status info.
+ */
+ if (biod.offset.QuadPart >= scp->length.QuadPart) {
+ osi_Log5(afsd_logp, "SKIP FetchData64 scp 0x%p, off 0x%x:%08x > length 0x%x:%08x",
+ scp, biod.offset.HighPart, biod.offset.LowPart,
+ scp->length.HighPart, scp->length.LowPart);
+
+ /* Clone the current status info */
+ scp_locked = cm_CloneStatus(scp, userp, scp_locked, &afsStatus, &volSync);
+
+ /* status info complete, fill pages with zeros */
+ for (qdp = biod.bufListEndp;
+ qdp;
+ qdp = (osi_queueData_t *) osi_QPrev(&qdp->q)) {
+ tbufp = osi_GetQData(qdp);
+ bufferp=tbufp->datap;
+ memset(bufferp, 0, cm_data.buf_blockSize);
+ }
+
+ /* no need to contact the file server */
+ goto fetchingcompleted;
+ }
+
+ if (scp_locked) {
+ lock_ReleaseWrite(&scp->rw);
+ scp_locked = 0;
+ }
+
+ /* now make the call */
do {
code = cm_ConnFromFID(&scp->fid, userp, reqp, &connp);
if (code)
if (temp == sizeof(afs_int32)) {
nbytes = ntohl(nbytes);
FillInt64(length_found, nbytes_hi, nbytes);
- if (length_found > biod.length)
- code = (rxcallp->error < 0) ? rxcallp->error : -1;
+ if (length_found > biod.length) {
+ /*
+ * prior to 1.4.12 and 1.5.65 the file server would return
+ * (filesize - offset) if the requested offset was greater than
+ * the filesize. The correct return value would have been zero.
+ * Force a retry by returning an RX_PROTOCOL_ERROR. If the cause
+ * is a race between two RPCs issues by this cache manager, the
+ * correct thing will happen the second time.
+ */
+ osi_Log0(afsd_logp, "cm_GetBuffer length_found > biod.length");
+ fs_fetchdata_offset_bug = 1;
+ }
} else {
- code = (rxcallp->error < 0) ? rxcallp->error : -1;
+ osi_Log1(afsd_logp, "cm_GetBuffer rx_Read32 returns %d != 4", temp);
+ code = (rxcallp->error < 0) ? rxcallp->error : RX_PROTOCOL_ERROR;
}
}
/* for the moment, nbytes_hi will always be 0 if code == 0
if (code == 0) {
temp = rx_Read32(rxcallp, &nbytes);
if (temp == sizeof(afs_int32)) {
- nbytes = ntohl(nbytes);
- if (nbytes > biod.length)
- code = (rxcallp->error < 0) ? rxcallp->error : -1;
+ length_found = ntohl(nbytes);
+ if (length_found > biod.length) {
+ /*
+ * prior to 1.4.12 and 1.5.65 the file server would return
+ * (filesize - offset) if the requested offset was greater than
+ * the filesize. The correct return value would have been zero.
+ * Force a retry by returning an RX_PROTOCOL_ERROR. If the cause
+ * is a race between two RPCs issues by this cache manager, the
+ * correct thing will happen the second time.
+ */
+ osi_Log0(afsd_logp, "cm_GetBuffer length_found > biod.length");
+ fs_fetchdata_offset_bug = 1;
+ }
+ }
+ else {
+ osi_Log1(afsd_logp, "cm_GetBuffer rx_Read32 returns %d != 4", temp);
+ code = (rxcallp->error < 0) ? rxcallp->error : RX_PROTOCOL_ERROR;
}
- else
- code = (rxcallp->error < 0) ? rxcallp->error : -1;
}
#endif
}
else
bufferp = NULL;
- /* fill nbytes of data from the pipe into the pages.
+ /* fill length_found of data from the pipe into the pages.
* When we stop, qdp will point at the last page we're
* dealing with, and bufferp will tell us where we
* stopped. We'll need this info below when we clear
* the remainder of the last page out (and potentially
* clear later pages out, if we fetch past EOF).
*/
- while (nbytes > 0) {
+ while (length_found > 0) {
/* assert that there are still more buffers;
- * our check above for nbytes being less than
+ * our check above for length_found being less than
* biod.length should ensure this.
*/
osi_assertx(bufferp != NULL, "null cm_buf_t");
/* read rbytes of data */
- rbytes = (nbytes > cm_data.buf_blockSize? cm_data.buf_blockSize : nbytes);
+ rbytes = (afs_uint32)(length_found > cm_data.buf_blockSize ? cm_data.buf_blockSize : length_found);
temp = rx_Read(rxcallp, bufferp, rbytes);
if (temp < rbytes) {
- code = (rxcallp->error < 0) ? rxcallp->error : -1;
+ /*
+ * If the file server returned (filesize - offset),
+ * then the first rx_Read will return zero octets of data.
+ * If it does, do not treat it as an error. Correct the
+ * length_found and continue as if the file server said
+ * it was sending us zero octets of data.
+ */
+ if (fs_fetchdata_offset_bug && first_read)
+ length_found = 0;
+ else
+ code = (rxcallp->error < 0) ? rxcallp->error : RX_PROTOCOL_ERROR;
break;
}
+ first_read = 0;
/* allow read-while-fetching.
* if this is the last buffer, clear the
lock_ReleaseWrite(&scp->rw);
/* and adjust counters */
- nbytes -= temp;
+ length_found -= temp;
/* and move to the next buffer */
- if (nbytes != 0) {
+ if (length_found != 0) {
qdp = (osi_queueData_t *) osi_QPrev(&qdp->q);
if (qdp) {
tbufp = osi_GetQData(qdp);
if (code1 == RXKADUNKNOWNKEY)
osi_Log0(afsd_logp, "CALL EndCall returns RXKADUNKNOWNKEY");
+ /* If we are avoiding a file server bug, ignore the error state */
+ if (fs_fetchdata_offset_bug && first_read && length_found == 0 && code == -451) {
+ /* Clone the current status info and clear the error state */
+ scp_locked = cm_CloneStatus(scp, userp, scp_locked, &afsStatus, &volSync);
+ if (scp_locked) {
+ lock_ReleaseWrite(&scp->rw);
+ scp_locked = 0;
+ }
+ code = 0;
/* Prefer the error value from FetchData over rx_EndCall */
- if (code == 0 && code1 != 0)
+ } else if (code == 0 && code1 != 0)
code = code1;
osi_Log0(afsd_logp, "CALL FetchData DONE");
fetchingcompleted:
code = cm_MapRPCError(code, reqp);
- lock_ObtainWrite(&scp->rw);
+ if (!scp_locked)
+ lock_ObtainWrite(&scp->rw);
/* we know that no one else has changed the buffer, since we still have
* the fetching flag on the buffers, and we have the scp locked again.
git://git.openafs.org / openafs.git / blobdiff