/*
* Copyright 2000, International Business Machines Corporation and others.
- *$All Rights Reserved.
- *
+ * 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
#include <afsconfig.h>
#include "afs/param.h"
-RCSID
- ("$Header$");
#include "afs/sysincludes.h" /*Standard vendor system headers */
#include "afsincludes.h" /*AFS-based standard headers */
/* Forward declarations. */
static void afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint);
-static void afs_FreeDiscardedDCache(void);
+static int afs_FreeDiscardedDCache(void);
static void afs_DiscardDCache(struct dcache *);
static void afs_FreeDCache(struct dcache *);
/* For split cache */
afs_int32 afs_discardDCCount; /*!< Count of elts in discardDCList */
struct dcache *afs_freeDSList; /*!< Free list for disk slots */
struct dcache *afs_Initial_freeDSList; /*!< Initial list for above */
-#if defined(LINUX_USE_FH)
-struct fid cacheitems_fh;
-int cacheitems_fh_type;
-#else
-ino_t cacheInode; /*!< Inode for CacheItems file */
-#endif
+afs_dcache_id_t cacheInode; /*!< Inode for CacheItems file */
struct osi_file *afs_cacheInodep = 0; /*!< file for CacheItems inode */
struct afs_q afs_DLRU; /*!< dcache LRU */
afs_int32 afs_dhashsize = 1024;
afs_int32 afs_cacheStats; /*!< Stat entries in cache */
afs_int32 afs_blocksUsed; /*!< Number of blocks in use */
afs_int32 afs_blocksDiscarded; /*!<Blocks freed but not truncated */
-afs_int32 afs_fsfragsize = 1023; /*!< Underlying Filesystem minimum unit
+afs_int32 afs_fsfragsize = AFS_MIN_FRAGSIZE; /*!< Underlying Filesystem minimum unit
*of disk allocation usually 1K
*this value is (truefrag -1 ) to
*save a bunch of subtracts... */
int dcacheDisabled = 0;
-static int afs_UFSCacheFetchProc(struct rx_call *, struct osi_file *,
- afs_size_t, struct dcache *,
- struct vcache *, afs_size_t *,
- afs_size_t *, afs_int32);
-
-static int afs_UFSCacheStoreProc(struct rx_call *, struct osi_file *,
- afs_int32, struct vcache *,
- int *, afs_size_t *,
- afs_size_t *);
-
struct afs_cacheOps afs_UfsCacheOps = {
-#if defined(LINUX_USE_FH)
- osi_UFSOpen_fh,
-#else
+#ifndef HAVE_STRUCT_LABEL_SUPPORT
osi_UFSOpen,
-#endif
osi_UFSTruncate,
afs_osi_Read,
afs_osi_Write,
osi_UFSClose,
- afs_UFSRead,
- afs_UFSWrite,
- afs_UFSCacheFetchProc,
- afs_UFSCacheStoreProc,
+ afs_UFSReadUIO,
+ afs_UFSWriteUIO,
afs_UFSGetDSlot,
afs_UFSGetVolSlot,
afs_UFSHandleLink,
+#else
+ .open = osi_UFSOpen,
+ .truncate = osi_UFSTruncate,
+ .fread = afs_osi_Read,
+ .fwrite = afs_osi_Write,
+ .close = osi_UFSClose,
+ .vreadUIO = afs_UFSReadUIO,
+ .vwriteUIO = afs_UFSWriteUIO,
+ .GetDSlot = afs_UFSGetDSlot,
+ .GetVolSlot = afs_UFSGetVolSlot,
+ .HandleLink = afs_UFSHandleLink,
+#endif
};
struct afs_cacheOps afs_MemCacheOps = {
+#ifndef HAVE_STRUCT_LABEL_SUPPORT
afs_MemCacheOpen,
afs_MemCacheTruncate,
afs_MemReadBlk,
afs_MemWriteBlk,
afs_MemCacheClose,
- afs_MemRead,
- afs_MemWrite,
- afs_MemCacheFetchProc,
- afs_MemCacheStoreProc,
+ afs_MemReadUIO,
+ afs_MemWriteUIO,
afs_MemGetDSlot,
afs_MemGetVolSlot,
afs_MemHandleLink,
+#else
+ .open = afs_MemCacheOpen,
+ .truncate = afs_MemCacheTruncate,
+ .fread = afs_MemReadBlk,
+ .fwrite = afs_MemWriteBlk,
+ .close = afs_MemCacheClose,
+ .vreadUIO = afs_MemReadUIO,
+ .vwriteUIO = afs_MemWriteUIO,
+ .GetDSlot = afs_MemGetDSlot,
+ .GetVolSlot = afs_MemGetVolSlot,
+ .HandleLink = afs_MemHandleLink,
+#endif
};
int cacheDiskType; /*Type of backing disk for cache */
* 2 : RO
*/
static afs_int32
-afs_DCGetBucket(struct vcache *avc)
+afs_DCGetBucket(struct vcache *avc)
{
- if (!splitdcache)
+ if (!splitdcache)
return 1;
-
+
/* This should be replaced with some sort of user configurable function */
if (avc->f.states & CRO) {
return 2;
* \param newSize The new size to be adjusted to.
*
*/
-static void
+static void
afs_DCAdjustSize(struct dcache *adc, afs_int32 oldSize, afs_int32 newSize)
{
afs_int32 adjustSize = newSize - oldSize;
- if (!splitdcache)
+ if (!splitdcache)
return;
- switch (adc->bucket)
+ switch (adc->bucket)
{
case 0:
afs_blocksUsed_0 += adjustSize;
/*!
* Move a dcache from one bucket to another.
- *
+ *
* \param adc Operate on this dcache.
* \param size Size in bucket (?).
* \param newBucket Destination bucket.
*
*/
-static void
+static void
afs_DCMoveBucket(struct dcache *adc, afs_int32 size, afs_int32 newBucket)
{
- if (!splitdcache)
+ if (!splitdcache)
return;
- /* Substract size from old bucket. */
- switch (adc->bucket)
+ /* Substract size from old bucket. */
+ switch (adc->bucket)
{
case 0:
afs_blocksUsed_0 -= size;
/* Set new bucket and increase destination bucket size. */
adc->bucket = newBucket;
- switch (adc->bucket)
+ switch (adc->bucket)
{
case 0:
afs_blocksUsed_0 += size;
afs_blocksUsed_2 += size;
break;
}
-
+
return;
}
/*!
* Init split caches size.
*/
-static void
-afs_DCSizeInit(void)
+static void
+afs_DCSizeInit(void)
{
afs_blocksUsed_0 = afs_blocksUsed_1 = afs_blocksUsed_2 = 0;
}
* \param bucket
*/
static afs_int32
-afs_DCWhichBucket(afs_int32 phase, afs_int32 bucket)
+afs_DCWhichBucket(afs_int32 phase, afs_int32 bucket)
{
- if (!splitdcache)
+ if (!splitdcache)
return 0;
afs_pct1 = afs_blocksUsed_1 / (afs_cacheBlocks / 100);
afs_pct2 = afs_blocksUsed_2 / (afs_cacheBlocks / 100);
/* Short cut: if we don't know about it, try to kill it */
- if (phase < 2 && afs_blocksUsed_0)
+ if (phase < 2 && afs_blocksUsed_0)
return 0;
-
- if (afs_pct1 > afs_tpct1)
+
+ if (afs_pct1 > afs_tpct1)
return 1;
if (afs_pct2 > afs_tpct2)
return 2;
*/
void
-afs_StoreWarn(register afs_int32 acode, afs_int32 avolume,
- register afs_int32 aflags)
+afs_StoreWarn(afs_int32 acode, afs_int32 avolume,
+ afs_int32 aflags)
{
static char problem_fmt[] =
"afs: failed to store file in volume %d (%s)\n";
u_int afs_min_cache = 0;
/*!
+ * If there are waiters for the cache to drain, wake them if
+ * the number of free cache blocks reaches the CM_CACHESIZEDDRAINEDPCT.
+ *
+ * \note Environment:
+ * This routine must be called with the afs_xdcache lock held
+ * (in write mode).
+ */
+static void
+afs_WakeCacheWaitersIfDrained(void)
+{
+ if (afs_WaitForCacheDrain) {
+ if ((afs_blocksUsed - afs_blocksDiscarded) <=
+ PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
+ afs_WaitForCacheDrain = 0;
+ afs_osi_Wakeup(&afs_WaitForCacheDrain);
+ }
+ }
+}
+
+/*!
* Keeps the cache clean and free by truncating uneeded files, when used.
- * \param
- * \return
+ * \param
+ * \return
*/
void
afs_CacheTruncateDaemon(void)
afs_TruncateDaemonRunning = 1;
while (1) {
cb_lowat = PERCENT((CM_DCACHESPACEFREEPCT - CM_DCACHEEXTRAPCT), afs_cacheBlocks);
- MObtainWriteLock(&afs_xdcache, 266);
- if (afs_CacheTooFull) {
+ ObtainWriteLock(&afs_xdcache, 266);
+ if (afs_CacheTooFull || afs_WaitForCacheDrain) {
int space_needed, slots_needed;
/* if we get woken up, we should try to clean something out */
for (counter = 0; counter < 10; counter++) {
space_needed =
afs_blocksUsed - afs_blocksDiscarded - cb_lowat;
+ if (space_needed < 0)
+ space_needed = 0;
slots_needed =
dc_hiwat - afs_freeDCCount - afs_discardDCCount;
- afs_GetDownD(slots_needed, &space_needed, 0);
+ if (slots_needed < 0)
+ slots_needed = 0;
+ if (slots_needed || space_needed)
+ afs_GetDownD(slots_needed, &space_needed, 0);
if ((space_needed <= 0) && (slots_needed <= 0)) {
+ afs_CacheTooFull = 0;
break;
}
if (afs_termState == AFSOP_STOP_TRUNCDAEMON)
break;
}
- if (!afs_CacheIsTooFull())
+ if (!afs_CacheIsTooFull()) {
afs_CacheTooFull = 0;
+ afs_WakeCacheWaitersIfDrained();
+ }
} /* end of cache cleanup */
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
/*
* This is a defensive check to try to avoid starving threads
*/
while (afs_blocksDiscarded && !afs_WaitForCacheDrain
&& (afs_termState != AFSOP_STOP_TRUNCDAEMON)) {
- afs_FreeDiscardedDCache();
+ int code = afs_FreeDiscardedDCache();
+ if (code) {
+ /* If we can't free any discarded dcache entries, that's okay.
+ * We're just doing this in the background; if someone needs
+ * discarded entries freed, they will try it themselves and/or
+ * signal us that the cache is too full. In any case, we'll
+ * try doing this again the next time we run through the loop.
+ */
+ break;
+ }
}
/* See if we need to continue to run. Someone may have
afs_stats_AddTo(CTD_stats.CTD_sleepTime, CTD_tmpTime);
}
if (afs_termState == AFSOP_STOP_TRUNCDAEMON) {
-#ifdef AFS_AFSDB_ENV
afs_termState = AFSOP_STOP_AFSDB;
-#else
- afs_termState = AFSOP_STOP_RXEVENT;
-#endif
afs_osi_Wakeup(&afs_termState);
break;
}
*/
void
-afs_AdjustSize(register struct dcache *adc, register afs_int32 newSize)
+afs_AdjustSize(struct dcache *adc, afs_int32 newSize)
{
- register afs_int32 oldSize;
+ afs_int32 oldSize;
AFS_STATCNT(afs_AdjustSize);
* 1. only grab up to anumber victims if aneedSpace <= 0, not
* the whole set of MAXATONCE.
* 2. dynamically choose MAXATONCE to reflect severity of
- * demand: something like (*aneedSpace >> (logChunk - 9))
+ * demand: something like (*aneedSpace >> (logChunk - 9))
*
* \note N.B. if we're called with aneedSpace <= 0 and anumber > 0, that
* indicates that the cache is not properly configured/tuned or
afs_int32 i, j;
afs_hyper_t vtime;
int skip, phase;
- register struct vcache *tvc;
+ struct vcache *tvc;
afs_uint32 victims[MAXATONCE];
struct dcache *victimDCs[MAXATONCE];
afs_hyper_t victimTimes[MAXATONCE]; /* youngest (largest LRU time) first */
afs_uint32 maxVictimPtr; /* where it is */
int discard;
int curbucket;
-#if defined(AFS_FBSD80_ENV) && !defined(UKERNEL)
- int vfslocked;
-#endif
-
-#if defined(AFS_FBSD80_ENV) && !defined(UKERNEL)
- vfslocked = VFS_LOCK_GIANT(afs_globalVFS);
-#endif
AFS_STATCNT(afs_GetDownD);
if (CheckLock(&afs_xdcache) != -1)
osi_Panic("getdownd nolock");
/* decrement anumber first for all dudes in free list */
- /* SHOULD always decrement anumber first, even if aneedSpace >0,
+ /* SHOULD always decrement anumber first, even if aneedSpace >0,
* because we should try to free space even if anumber <=0 */
if (!aneedSpace || *aneedSpace <= 0) {
anumber -= afs_freeDCCount;
if (anumber <= 0) {
-#if defined(AFS_FBSD80_ENV) && !defined(UKERNEL)
- VFS_UNLOCK_GIANT(vfslocked);
-#endif
return; /* enough already free */
}
}
/* rewrite so phases include a better eligiblity for gc test*/
/*
* The phase variable manages reclaims. Set to 0, the first pass,
- * we don't reclaim active entries, or other than target bucket.
+ * we don't reclaim active entries, or other than target bucket.
* Set to 1, we reclaim even active ones in target bucket.
* Set to 2, we reclaim any inactive one.
- * Set to 3, we reclaim even active ones.
+ * Set to 3, we reclaim even active ones. On Solaris, we also reclaim
+ * entries whose corresponding vcache has a nonempty multiPage list, when
+ * possible.
*/
if (splitdcache) {
phase = 0;
* during the truncate operation.
*/
for (i = 0; i < victimPtr; i++) {
- tdc = afs_GetDSlot(victims[i], 0);
+ tdc = afs_GetValidDSlot(victims[i]);
/* We got tdc->tlock(R) here */
- if (tdc->refCount == 1)
+ if (tdc && tdc->refCount == 1)
victimDCs[i] = tdc;
else
victimDCs[i] = 0;
- ReleaseReadLock(&tdc->tlock);
- if (!victimDCs[i])
- afs_PutDCache(tdc);
+ if (tdc) {
+ ReleaseReadLock(&tdc->tlock);
+ if (!victimDCs[i])
+ afs_PutDCache(tdc);
+ }
}
for (i = 0; i < victimPtr; i++) {
/* q is first elt in dcache entry */
* have to verify, before proceeding, that there are no other
* references to this dcache entry, even now. Note that we
* compare with 1, since we bumped it above when we called
- * afs_GetDSlot to preserve the entry's identity.
+ * afs_GetValidDSlot to preserve the entry's identity.
*/
if (tdc && tdc->refCount == 1) {
unsigned char chunkFlags;
afs_size_t tchunkoffset = 0;
afid = &tdc->f.fid;
/* xdcache is lower than the xvcache lock */
- MReleaseWriteLock(&afs_xdcache);
- MObtainReadLock(&afs_xvcache);
+ ReleaseWriteLock(&afs_xdcache);
+ ObtainReadLock(&afs_xvcache);
tvc = afs_FindVCache(afid, 0, 0 /* no stats, no vlru */ );
- MReleaseReadLock(&afs_xvcache);
- MObtainWriteLock(&afs_xdcache, 527);
+ ReleaseReadLock(&afs_xvcache);
+ ObtainWriteLock(&afs_xdcache, 527);
skip = 0;
if (tdc->refCount > 1)
skip = 1;
if (!skip && (chunkFlags & IFAnyPages)) {
int code;
- MReleaseWriteLock(&afs_xdcache);
- MObtainWriteLock(&tvc->vlock, 543);
- if (tvc->multiPage) {
- skip = 1;
- goto endmultipage;
+ ReleaseWriteLock(&afs_xdcache);
+ ObtainWriteLock(&tvc->vlock, 543);
+ if (!QEmpty(&tvc->multiPage)) {
+ if (phase < 3 || osi_VM_MultiPageConflict(tvc, tdc)) {
+ skip = 1;
+ goto endmultipage;
+ }
}
/* block locking pages */
tvc->vstates |= VPageCleaning;
/* block getting new pages */
tvc->activeV++;
- MReleaseWriteLock(&tvc->vlock);
+ ReleaseWriteLock(&tvc->vlock);
/* One last recheck */
- MObtainWriteLock(&afs_xdcache, 333);
+ ObtainWriteLock(&afs_xdcache, 333);
chunkFlags = afs_indexFlags[tdc->index];
if (tdc->refCount > 1 || (chunkFlags & IFDataMod)
|| (osi_Active(tvc) && (tvc->f.states & CDCLock)
&& (chunkFlags & IFAnyPages))) {
skip = 1;
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
goto endputpage;
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
code = osi_VM_GetDownD(tvc, tdc);
- MObtainWriteLock(&afs_xdcache, 269);
+ ObtainWriteLock(&afs_xdcache, 269);
/* we actually removed all pages, clean and dirty */
if (code == 0) {
afs_indexFlags[tdc->index] &=
~(IFDirtyPages | IFAnyPages);
} else
skip = 1;
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
endputpage:
- MObtainWriteLock(&tvc->vlock, 544);
+ ObtainWriteLock(&tvc->vlock, 544);
if (--tvc->activeV == 0
&& (tvc->vstates & VRevokeWait)) {
tvc->vstates &= ~VRevokeWait;
afs_osi_Wakeup((char *)&tvc->vstates);
}
endmultipage:
- MReleaseWriteLock(&tvc->vlock);
+ ReleaseWriteLock(&tvc->vlock);
} else
#endif /* AFS_SUN5_ENV */
{
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
}
afs_PutVCache(tvc); /*XXX was AFS_FAST_RELE?*/
- MObtainWriteLock(&afs_xdcache, 528);
+ ObtainWriteLock(&afs_xdcache, 528);
if (afs_indexFlags[tdc->index] &
(IFDataMod | IFDirtyPages | IFAnyPages))
skip = 1;
j = 1; /* we reclaimed at least one victim */
}
}
- afs_PutDCache(tdc);
+ if (tdc)
+ afs_PutDCache(tdc);
} /* end of for victims loop */
if (phase < 5) {
}
} /* big while loop */
-#if defined(AFS_FBSD80_ENV) && !defined(UKERNEL)
- VFS_UNLOCK_GIANT(vfslocked);
-#endif
-
return;
} /*afs_GetDownD */
* (in write mode).
*/
void
-afs_FlushDCache(register struct dcache *adc)
+afs_FlushDCache(struct dcache *adc)
{
AFS_STATCNT(afs_FlushDCache);
/*
} else {
afs_FreeDCache(adc);
}
-
- if (afs_WaitForCacheDrain) {
- if (afs_blocksUsed <=
- PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
- afs_WaitForCacheDrain = 0;
- afs_osi_Wakeup(&afs_WaitForCacheDrain);
- }
- }
} /*afs_FlushDCache */
* \note Environment: called with afs_xdcache lock write-locked.
*/
static void
-afs_FreeDCache(register struct dcache *adc)
+afs_FreeDCache(struct dcache *adc)
{
/* Thread on free list, update free list count and mark entry as
* freed in its indexFlags element. Also, ensure DCache entry gets
afs_indexFlags[adc->index] |= IFFree;
adc->dflags |= DFEntryMod;
- if (afs_WaitForCacheDrain) {
- if ((afs_blocksUsed - afs_blocksDiscarded) <=
- PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
- afs_WaitForCacheDrain = 0;
- afs_osi_Wakeup(&afs_WaitForCacheDrain);
- }
- }
+ afs_WakeCacheWaitersIfDrained();
} /* afs_FreeDCache */
/*!
*/
static void
-afs_DiscardDCache(register struct dcache *adc)
+afs_DiscardDCache(struct dcache *adc)
{
- register afs_int32 size;
+ afs_int32 size;
AFS_STATCNT(afs_DiscardDCache);
adc->dflags |= DFEntryMod;
afs_indexFlags[adc->index] |= IFDiscarded;
- if (afs_WaitForCacheDrain) {
- if ((afs_blocksUsed - afs_blocksDiscarded) <=
- PERCENT(CM_CACHESIZEDRAINEDPCT, afs_cacheBlocks)) {
- afs_WaitForCacheDrain = 0;
- afs_osi_Wakeup(&afs_WaitForCacheDrain);
+ afs_WakeCacheWaitersIfDrained();
+} /*afs_DiscardDCache */
+
+/**
+ * Get a dcache entry from the discard or free list
+ *
+ * @param[in] indexp A pointer to the head of the dcache free list or discard
+ * list (afs_freeDCList, or afs_discardDCList)
+ *
+ * @return A dcache from that list, or NULL if none could be retrieved.
+ *
+ * @pre afs_xdcache is write-locked
+ */
+static struct dcache *
+afs_GetDSlotFromList(afs_int32 *indexp)
+{
+ struct dcache *tdc;
+
+ for ( ; *indexp != NULLIDX; indexp = &afs_dvnextTbl[*indexp]) {
+ tdc = afs_GetUnusedDSlot(*indexp);
+ if (tdc) {
+ osi_Assert(tdc->refCount == 1);
+ ReleaseReadLock(&tdc->tlock);
+ *indexp = afs_dvnextTbl[tdc->index];
+ afs_dvnextTbl[tdc->index] = NULLIDX;
+ return tdc;
}
}
-
-} /*afs_DiscardDCache */
+ return NULL;
+}
/*!
* Free the next element on the list of discarded cache elements.
+ *
+ * Returns -1 if we encountered an error preventing us from freeing a
+ * discarded dcache, or 0 on success.
*/
-static void
+static int
afs_FreeDiscardedDCache(void)
{
- register struct dcache *tdc;
- register struct osi_file *tfile;
- register afs_int32 size;
+ struct dcache *tdc;
+ struct osi_file *tfile;
+ afs_int32 size;
AFS_STATCNT(afs_FreeDiscardedDCache);
- MObtainWriteLock(&afs_xdcache, 510);
+ ObtainWriteLock(&afs_xdcache, 510);
if (!afs_blocksDiscarded) {
- MReleaseWriteLock(&afs_xdcache);
- return;
+ ReleaseWriteLock(&afs_xdcache);
+ return 0;
}
/*
* Get an entry from the list of discarded cache elements
*/
- tdc = afs_GetDSlot(afs_discardDCList, 0);
- osi_Assert(tdc->refCount == 1);
- ReleaseReadLock(&tdc->tlock);
+ tdc = afs_GetDSlotFromList(&afs_discardDCList);
+ if (!tdc) {
+ ReleaseWriteLock(&afs_xdcache);
+ return -1;
+ }
- afs_discardDCList = afs_dvnextTbl[tdc->index];
- afs_dvnextTbl[tdc->index] = NULLIDX;
afs_discardDCCount--;
size = ((tdc->f.chunkBytes + afs_fsfragsize) ^ afs_fsfragsize) >> 10; /* round up */
afs_blocksDiscarded -= size;
afs_stats_cmperf.cacheBlocksDiscarded = afs_blocksDiscarded;
/* We can lock because we just took it off the free list */
ObtainWriteLock(&tdc->lock, 626);
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
/*
* Truncate the element to reclaim its space
*/
-#if defined(LINUX_USE_FH)
- tfile = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
- tfile = afs_CFileOpen(tdc->f.inode);
-#endif
+ tfile = afs_CFileOpen(&tdc->f.inode);
afs_CFileTruncate(tfile, 0);
afs_CFileClose(tfile);
afs_AdjustSize(tdc, 0);
/*
* Free the element we just truncated
*/
- MObtainWriteLock(&afs_xdcache, 511);
+ ObtainWriteLock(&afs_xdcache, 511);
afs_indexFlags[tdc->index] &= ~IFDiscarded;
afs_FreeDCache(tdc);
tdc->f.states &= ~(DRO|DBackup|DRW);
ReleaseWriteLock(&tdc->lock);
afs_PutDCache(tdc);
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
+
+ return 0;
}
/*!
while (afs_blocksDiscarded
&& (afs_blocksUsed >
PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks))) {
- afs_FreeDiscardedDCache();
+ int code = afs_FreeDiscardedDCache();
+ if (code) {
+ /* Callers depend on us to get the afs_blocksDiscarded count down.
+ * If we cannot do that, the callers can spin by calling us over
+ * and over. Panic for now until we can figure out something
+ * better. */
+ osi_Panic("Error freeing discarded dcache");
+ }
}
return 0;
}
}
#else
tdc->dflags &= ~DFEntryMod;
- afs_WriteDCache(tdc, 1);
+ osi_Assert(afs_WriteDCache(tdc, 1) == 0);
#endif
}
* Nothing interesting.
*/
int
-afs_PutDCache(register struct dcache *adc)
+afs_PutDCache(struct dcache *adc)
{
AFS_STATCNT(afs_PutDCache);
ObtainWriteLock(&adc->tlock, 276);
* Both pvnLock and lock are write held.
*/
void
-afs_TryToSmush(register struct vcache *avc, struct AFS_UCRED *acred, int sync)
+afs_TryToSmush(struct vcache *avc, afs_ucred_t *acred, int sync)
{
- register struct dcache *tdc;
- register int index;
- register int i;
+ struct dcache *tdc;
+ int index;
+ int i;
AFS_STATCNT(afs_TryToSmush);
afs_Trace2(afs_iclSetp, CM_TRACE_TRYTOSMUSH, ICL_TYPE_POINTER, avc,
ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length));
* Get the hash chain containing all dce's for this fid
*/
i = DVHash(&avc->f.fid);
- MObtainWriteLock(&afs_xdcache, 277);
+ ObtainWriteLock(&afs_xdcache, 277);
for (index = afs_dvhashTbl[i]; index != NULLIDX; index = i) {
i = afs_dvnextTbl[index]; /* next pointer this hash table */
if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
int releaseTlock = 1;
- tdc = afs_GetDSlot(index, NULL);
+ tdc = afs_GetValidDSlot(index);
+ if (!tdc) {
+ /* afs_TryToSmush is best-effort; we may not actually discard
+ * everything, so failure to discard a dcache due to an i/o
+ * error is okay. */
+ continue;
+ }
if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
if (sync) {
if ((afs_indexFlags[index] & IFDataMod) == 0
}
ReleaseWriteLock(&avc->vlock);
#endif
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
/*
- * It's treated like a callback so that when we do lookups we'll
+ * It's treated like a callback so that when we do lookups we'll
* invalidate the unique bit if any
* trytoSmush occured during the lookup call
*/
* Description
* Given the cached info for a file, return the number of chunks that
* are not available from the dcache.
- *
+ *
* Parameters:
* avc: Pointer to the (held) vcache entry to look in.
- *
+ *
* Returns:
* The number of chunks which are not currently cached.
- *
+ *
* Environment:
* The vcache entry is held upon entry.
*/
*/
if (avc->f.fid.Fid.Vnode & 1 || vType(avc) == VDIR)
totalChunks = 1;
-
+
/*
printf("Should have %d chunks for %u bytes\n",
totalChunks, (totalLength + 1));
*/
i = DVHash(&avc->f.fid);
- MObtainWriteLock(&afs_xdcache, 1001);
+ ObtainWriteLock(&afs_xdcache, 1001);
for (index = afs_dvhashTbl[i]; index != NULLIDX; index = i) {
i = afs_dvnextTbl[index];
if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
- tdc = afs_GetDSlot(index, NULL);
- if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
- totalChunks--;
- }
- ReleaseReadLock(&tdc->tlock);
- afs_PutDCache(tdc);
+ tdc = afs_GetValidDSlot(index);
+ if (tdc) {
+ if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
+ totalChunks--;
+ }
+ ReleaseReadLock(&tdc->tlock);
+ afs_PutDCache(tdc);
+ }
}
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
/*printf("Missing %d chunks\n", totalChunks);*/
*/
struct dcache *
-afs_FindDCache(register struct vcache *avc, afs_size_t abyte)
+afs_FindDCache(struct vcache *avc, afs_size_t abyte)
{
afs_int32 chunk;
- register afs_int32 i, index;
- register struct dcache *tdc = NULL;
+ afs_int32 i, index;
+ struct dcache *tdc = NULL;
AFS_STATCNT(afs_FindDCache);
chunk = AFS_CHUNK(abyte);
* after write-locking the dcache.
*/
i = DCHash(&avc->f.fid, chunk);
- MObtainWriteLock(&afs_xdcache, 278);
- for (index = afs_dchashTbl[i]; index != NULLIDX;) {
+ ObtainWriteLock(&afs_xdcache, 278);
+ for (index = afs_dchashTbl[i]; index != NULLIDX; index = afs_dcnextTbl[index]) {
if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
- tdc = afs_GetDSlot(index, NULL);
+ tdc = afs_GetValidDSlot(index);
+ if (!tdc) {
+ /* afs_FindDCache is best-effort; we may not find the given
+ * file/offset, so if we cannot find the given dcache due to
+ * i/o errors, that is okay. */
+ continue;
+ }
ReleaseReadLock(&tdc->tlock);
if (!FidCmp(&tdc->f.fid, &avc->f.fid) && chunk == tdc->f.chunk) {
break; /* leaving refCount high for caller */
}
afs_PutDCache(tdc);
}
- index = afs_dcnextTbl[index];
}
if (index != NULLIDX) {
hset(afs_indexTimes[tdc->index], afs_indexCounter);
hadd32(afs_indexCounter, 1);
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
return tdc;
- }
- MReleaseWriteLock(&afs_xdcache);
+ }
+ ReleaseWriteLock(&afs_xdcache);
return NULL;
} /*afs_FindDCache */
-
-/*
- * afs_UFSCacheStoreProc
- *
- * Description:
- * Called upon store.
- *
- * Parameters:
- * acall : Ptr to the Rx call structure involved.
- * afile : Ptr to the related file descriptor.
- * alen : Size of the file in bytes.
- * avc : Ptr to the vcache entry.
- * shouldWake : is it "safe" to return early from close() ?
- * abytesToXferP : Set to the number of bytes to xfer.
- * NOTE: This parameter is only used if AFS_NOSTATS
- * is not defined.
- * abytesXferredP : Set to the number of bytes actually xferred.
- * NOTE: This parameter is only used if AFS_NOSTATS
- * is not defined.
- *
- * Environment:
- * Nothing interesting.
- */
-static int
-afs_UFSCacheStoreProc(register struct rx_call *acall, struct osi_file *afile,
- register afs_int32 alen, struct vcache *avc,
- int *shouldWake, afs_size_t * abytesToXferP,
- afs_size_t * abytesXferredP)
+/* only call these from afs_AllocDCache() */
+static struct dcache *
+afs_AllocFreeDSlot(void)
{
- afs_int32 code, got;
- register char *tbuffer;
- register int tlen;
-
- AFS_STATCNT(UFS_CacheStoreProc);
-
-#ifndef AFS_NOSTATS
- /*
- * In this case, alen is *always* the amount of data we'll be trying
- * to ship here.
- */
- (*abytesToXferP) = alen;
- (*abytesXferredP) = 0;
-#endif /* AFS_NOSTATS */
+ struct dcache *tdc;
- afs_Trace4(afs_iclSetp, CM_TRACE_STOREPROC, ICL_TYPE_POINTER, avc,
- ICL_TYPE_FID, &(avc->f.fid), ICL_TYPE_OFFSET,
- ICL_HANDLE_OFFSET(avc->f.m.Length), ICL_TYPE_INT32, alen);
- tbuffer = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
- while (alen > 0) {
- tlen = (alen > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : alen);
- got = afs_osi_Read(afile, -1, tbuffer, tlen);
- if ((got < 0)
-#if defined(KERNEL_HAVE_UERROR)
- || (got != tlen && getuerror())
-#endif
- ) {
- osi_FreeLargeSpace(tbuffer);
- return EIO;
- }
- afs_Trace2(afs_iclSetp, CM_TRACE_STOREPROC2, ICL_TYPE_OFFSET,
- ICL_HANDLE_OFFSET(*tbuffer), ICL_TYPE_INT32, got);
- RX_AFS_GUNLOCK();
- code = rx_Write(acall, tbuffer, got); /* writing 0 bytes will
- * push a short packet. Is that really what we want, just because the
- * data didn't come back from the disk yet? Let's try it and see. */
- RX_AFS_GLOCK();
-#ifndef AFS_NOSTATS
- (*abytesXferredP) += code;
-#endif /* AFS_NOSTATS */
- if (code != got) {
- code = rx_Error(acall);
- osi_FreeLargeSpace(tbuffer);
- return code ? code : -33;
- }
- alen -= got;
- /*
- * If file has been locked on server, we can allow the store
- * to continue.
- */
- if (shouldWake && *shouldWake && (rx_GetRemoteStatus(acall) & 1)) {
- *shouldWake = 0; /* only do this once */
- afs_wakeup(avc);
- }
+ tdc = afs_GetDSlotFromList(&afs_freeDCList);
+ if (!tdc) {
+ return NULL;
}
- afs_Trace4(afs_iclSetp, CM_TRACE_STOREPROC, ICL_TYPE_POINTER, avc,
- ICL_TYPE_FID, &(avc->f.fid), ICL_TYPE_OFFSET,
- ICL_HANDLE_OFFSET(avc->f.m.Length), ICL_TYPE_INT32, alen);
- osi_FreeLargeSpace(tbuffer);
- return 0;
-
-} /* afs_UFSCacheStoreProc */
+ afs_indexFlags[tdc->index] &= ~IFFree;
+ ObtainWriteLock(&tdc->lock, 604);
+ afs_freeDCCount--;
-
-/*
- * afs_UFSCacheFetchProc
- *
- * Description:
- * Routine called on fetch; also tells people waiting for data
- * that more has arrived.
- *
- * Parameters:
- * acall : Ptr to the Rx call structure.
- * afile : File descriptor for the cache file.
- * abase : Base offset to fetch.
- * adc : Ptr to the dcache entry for the file, write-locked.
- * avc : Ptr to the vcache entry for the file.
- * abytesToXferP : Set to the number of bytes to xfer.
- * NOTE: This parameter is only used if AFS_NOSTATS
- * is not defined.
- * abytesXferredP : Set to the number of bytes actually xferred.
- * NOTE: This parameter is only used if AFS_NOSTATS
- * is not defined.
- *
- * Environment:
- * Nothing interesting.
- */
-
-static int
-afs_UFSCacheFetchProc(register struct rx_call *acall, struct osi_file *afile,
- afs_size_t abase, struct dcache *adc,
- struct vcache *avc, afs_size_t * abytesToXferP,
- afs_size_t * abytesXferredP, afs_int32 lengthFound)
+ return tdc;
+}
+static struct dcache *
+afs_AllocDiscardDSlot(afs_int32 lock)
{
- afs_int32 length;
- register afs_int32 code;
- register char *tbuffer;
- register int tlen;
- int moredata = 0;
-
- AFS_STATCNT(UFS_CacheFetchProc);
- osi_Assert(WriteLocked(&adc->lock));
- afile->offset = 0; /* Each time start from the beginning */
- length = lengthFound;
-#ifndef AFS_NOSTATS
- (*abytesToXferP) = 0;
- (*abytesXferredP) = 0;
-#endif /* AFS_NOSTATS */
- tbuffer = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
- adc->validPos = abase;
- do {
- if (moredata) {
- RX_AFS_GUNLOCK();
- code = rx_Read(acall, (char *)&length, sizeof(afs_int32));
- RX_AFS_GLOCK();
- length = ntohl(length);
- if (code != sizeof(afs_int32)) {
- osi_FreeLargeSpace(tbuffer);
- code = rx_Error(acall);
- return (code ? code : -1); /* try to return code, not -1 */
- }
- }
- /*
- * The fetch protocol is extended for the AFS/DFS translator
- * to allow multiple blocks of data, each with its own length,
- * to be returned. As long as the top bit is set, there are more
- * blocks expected.
- *
- * We do not do this for AFS file servers because they sometimes
- * return large negative numbers as the transfer size.
- */
- if (avc->f.states & CForeign) {
- moredata = length & 0x80000000;
- length &= ~0x80000000;
- } else {
- moredata = 0;
- }
-#ifndef AFS_NOSTATS
- (*abytesToXferP) += length;
-#endif /* AFS_NOSTATS */
- while (length > 0) {
- tlen = (length > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : length);
-#ifdef RX_KERNEL_TRACE
- afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP, ICL_TYPE_STRING,
- "before rx_Read");
-#endif
- RX_AFS_GUNLOCK();
- code = rx_Read(acall, tbuffer, tlen);
- RX_AFS_GLOCK();
-#ifdef RX_KERNEL_TRACE
- afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP, ICL_TYPE_STRING,
- "after rx_Read");
-#endif
-#ifndef AFS_NOSTATS
- (*abytesXferredP) += code;
-#endif /* AFS_NOSTATS */
- if (code != tlen) {
- osi_FreeLargeSpace(tbuffer);
- afs_Trace3(afs_iclSetp, CM_TRACE_FETCH64READ,
- ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code,
- ICL_TYPE_INT32, length);
- return -34;
- }
- code = afs_osi_Write(afile, -1, tbuffer, tlen);
- if (code != tlen) {
- osi_FreeLargeSpace(tbuffer);
- return EIO;
- }
- abase += tlen;
- length -= tlen;
- adc->validPos = abase;
- if (afs_osi_Wakeup(&adc->validPos) == 0)
- afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAKE, ICL_TYPE_STRING,
- __FILE__, ICL_TYPE_INT32, __LINE__,
- ICL_TYPE_POINTER, adc, ICL_TYPE_INT32,
- adc->dflags);
- }
- } while (moredata);
- osi_FreeLargeSpace(tbuffer);
- return 0;
+ struct dcache *tdc;
+ afs_uint32 size = 0;
+ struct osi_file *file;
-} /* afs_UFSCacheFetchProc */
+ tdc = afs_GetDSlotFromList(&afs_discardDCList);
+ if (!tdc) {
+ return NULL;
+ }
+ afs_indexFlags[tdc->index] &= ~IFDiscarded;
+ ObtainWriteLock(&tdc->lock, 605);
+ afs_discardDCCount--;
+ size =
+ ((tdc->f.chunkBytes +
+ afs_fsfragsize) ^ afs_fsfragsize) >> 10;
+ tdc->f.states &= ~(DRO|DBackup|DRW);
+ afs_DCMoveBucket(tdc, size, 0);
+ afs_blocksDiscarded -= size;
+ afs_stats_cmperf.cacheBlocksDiscarded = afs_blocksDiscarded;
+ if ((lock & 2)) {
+ /* Truncate the chunk so zeroes get filled properly */
+ file = afs_CFileOpen(&tdc->f.inode);
+ afs_CFileTruncate(file, 0);
+ afs_CFileClose(file);
+ afs_AdjustSize(tdc, 0);
+ }
+
+ return tdc;
+}
/*!
* Get a fresh dcache from the free or discarded list.
*
* \return The new dcache.
*/
-struct dcache *afs_AllocDCache(struct vcache *avc,
- afs_int32 chunk,
- afs_int32 lock,
- struct VenusFid *ashFid)
+struct dcache *
+afs_AllocDCache(struct vcache *avc, afs_int32 chunk, afs_int32 lock,
+ struct VenusFid *ashFid)
{
struct dcache *tdc = NULL;
- afs_uint32 size = 0;
- struct osi_file *file;
-
- if (afs_discardDCList == NULLIDX
- || ((lock & 2) && afs_freeDCList != NULLIDX)) {
- afs_indexFlags[afs_freeDCList] &= ~IFFree;
- tdc = afs_GetDSlot(afs_freeDCList, 0);
- osi_Assert(tdc->refCount == 1);
- ReleaseReadLock(&tdc->tlock);
- ObtainWriteLock(&tdc->lock, 604);
- afs_freeDCList = afs_dvnextTbl[tdc->index];
- afs_freeDCCount--;
+ /* if (lock & 2), prefer 'free' dcaches; otherwise, prefer 'discard'
+ * dcaches. In either case, try both if our first choice doesn't work. */
+ if ((lock & 2)) {
+ tdc = afs_AllocFreeDSlot();
+ if (!tdc) {
+ tdc = afs_AllocDiscardDSlot(lock);
+ }
} else {
- afs_indexFlags[afs_discardDCList] &= ~IFDiscarded;
- tdc = afs_GetDSlot(afs_discardDCList, 0);
- osi_Assert(tdc->refCount == 1);
- ReleaseReadLock(&tdc->tlock);
- ObtainWriteLock(&tdc->lock, 605);
- afs_discardDCList = afs_dvnextTbl[tdc->index];
- afs_discardDCCount--;
- size =
- ((tdc->f.chunkBytes +
- afs_fsfragsize) ^ afs_fsfragsize) >> 10;
- tdc->f.states &= ~(DRO|DBackup|DRW);
- afs_DCMoveBucket(tdc, size, 0);
- afs_blocksDiscarded -= size;
- afs_stats_cmperf.cacheBlocksDiscarded = afs_blocksDiscarded;
- if (lock & 2) {
- /* Truncate the chunk so zeroes get filled properly */
-#if defined(LINUX_USE_FH)
- file = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
- file = afs_CFileOpen(tdc->f.inode);
-#endif
- afs_CFileTruncate(file, 0);
- afs_CFileClose(file);
- afs_AdjustSize(tdc, 0);
+ tdc = afs_AllocDiscardDSlot(lock);
+ if (!tdc) {
+ tdc = afs_AllocFreeDSlot();
}
}
+ if (!tdc) {
+ return NULL;
+ }
/*
* Locks held:
* The vcache entry pointed to by avc is unlocked upon entry.
*/
-struct tlocal1 {
- struct AFSVolSync tsync;
- struct AFSFetchStatus OutStatus;
- struct AFSCallBack CallBack;
-};
-
/*
* Update the vnode-to-dcache hint if we can get the vnode lock
* right away. Assumes dcache entry is at least read-locked.
/* avc - Write-locked unless aflags & 1 */
struct dcache *
-afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
- register struct vrequest *areq, afs_size_t * aoffset,
+afs_GetDCache(struct vcache *avc, afs_size_t abyte,
+ struct vrequest *areq, afs_size_t * aoffset,
afs_size_t * alen, int aflags)
{
- register afs_int32 i, code, code1 = 0, shortcut;
+ afs_int32 i, code, shortcut;
#if defined(AFS_AIX32_ENV) || defined(AFS_SGI_ENV)
- register afs_int32 adjustsize = 0;
+ afs_int32 adjustsize = 0;
#endif
int setLocks;
afs_int32 index;
afs_int32 us;
afs_int32 chunk;
- afs_size_t maxGoodLength; /* amount of good data at server */
- struct rx_call *tcall;
afs_size_t Position = 0;
-#ifdef AFS_64BIT_CLIENT
- afs_size_t tsize;
- afs_size_t lengthFound; /* as returned from server */
-#endif /* AFS_64BIT_CLIENT */
afs_int32 size, tlen; /* size of segment to transfer */
- struct tlocal1 *tsmall = 0;
- register struct dcache *tdc;
- register struct osi_file *file;
- register struct afs_conn *tc;
+ struct afs_FetchOutput *tsmall = 0;
+ struct dcache *tdc;
+ struct osi_file *file;
+ struct afs_conn *tc;
int downDCount = 0;
struct server *newCallback = NULL;
char setNewCallback;
int doAdjustSize = 0;
int doReallyAdjustSize = 0;
int overWriteWholeChunk = 0;
+ struct rx_connection *rxconn;
- XSTATS_DECLS;
#ifndef AFS_NOSTATS
- struct afs_stats_xferData *xferP; /* Ptr to this op's xfer struct */
- osi_timeval_t xferStartTime, /*FS xfer start time */
- xferStopTime; /*FS xfer stop time */
- afs_size_t bytesToXfer; /* # bytes to xfer */
- afs_size_t bytesXferred; /* # bytes actually xferred */
struct afs_stats_AccessInfo *accP; /*Ptr to access record in stats */
int fromReplica; /*Are we reading from a replica? */
int numFetchLoops; /*# times around the fetch/analyze loop */
* entries from the free list, and thereby assuming them to be not
* referenced and not locked.
*/
- MObtainReadLock(&afs_xdcache);
+ ObtainReadLock(&afs_xdcache);
dcLocked = (0 == NBObtainSharedLock(&tdc->lock, 601));
if (dcLocked && (tdc->index != NULLIDX)
&& !FidCmp(&tdc->f.fid, &avc->f.fid) && chunk == tdc->f.chunk
&& !(afs_indexFlags[tdc->index] & (IFFree | IFDiscarded))) {
- /* got the right one. It might not be the right version, and it
+ /* got the right one. It might not be the right version, and it
* might be fetching, but it's the right dcache entry.
*/
/* All this code should be integrated better with what follows:
tdc->refCount++;
ReleaseWriteLock(&tdc->tlock);
- MReleaseReadLock(&afs_xdcache);
+ ReleaseReadLock(&afs_xdcache);
shortcut = 1;
if (hsame(tdc->f.versionNo, avc->f.m.DataVersion)
&& !(tdc->dflags & DFFetching)) {
afs_stats_cmperf.dcacheHits++;
- MObtainWriteLock(&afs_xdcache, 559);
+ ObtainWriteLock(&afs_xdcache, 559);
QRemove(&tdc->lruq);
QAdd(&afs_DLRU, &tdc->lruq);
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
/* Locks held:
* avc->lock(R) if setLocks && !slowPass
} else {
if (dcLocked)
ReleaseSharedLock(&tdc->lock);
- MReleaseReadLock(&afs_xdcache);
+ ReleaseReadLock(&afs_xdcache);
}
if (!shortcut)
*/
if (!tdc) { /* If the hint wasn't the right dcache entry */
+ int dslot_error = 0;
/*
* Hash on the [fid, chunk] and get the corresponding dcache index
* after write-locking the dcache.
/* check to make sure our space is fine */
afs_MaybeWakeupTruncateDaemon();
- MObtainWriteLock(&afs_xdcache, 280);
+ ObtainWriteLock(&afs_xdcache, 280);
us = NULLIDX;
- for (index = afs_dchashTbl[i]; index != NULLIDX;) {
+ for (index = afs_dchashTbl[i]; index != NULLIDX; us = index, index = afs_dcnextTbl[index]) {
if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
- tdc = afs_GetDSlot(index, NULL);
+ tdc = afs_GetValidDSlot(index);
+ if (!tdc) {
+ /* we got an i/o error when trying to get the given dslot,
+ * but do not bail out just yet; it is possible the dcache
+ * we're looking for is elsewhere, so it doesn't matter if
+ * we can't load this one. */
+ dslot_error = 1;
+ continue;
+ }
ReleaseReadLock(&tdc->tlock);
/*
* Locks held:
afs_dcnextTbl[index] = afs_dchashTbl[i];
afs_dchashTbl[i] = index;
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
ObtainSharedLock(&tdc->lock, 606);
break; /* leaving refCount high for caller */
}
afs_PutDCache(tdc);
tdc = 0;
}
- us = index;
- index = afs_dcnextTbl[index];
}
/*
afs_Trace2(afs_iclSetp, CM_TRACE_GETDCACHE1, ICL_TYPE_POINTER,
avc, ICL_TYPE_INT32, chunk);
- /* Make sure there is a free dcache entry for us to use */
- if (afs_discardDCList == NULLIDX && afs_freeDCList == NULLIDX) {
- while (1) {
- if (!setLocks)
- avc->f.states |= CDCLock;
- /* just need slots */
- afs_GetDownD(5, (int *)0, afs_DCGetBucket(avc));
- if (!setLocks)
- avc->f.states &= ~CDCLock;
- if (afs_discardDCList != NULLIDX
- || afs_freeDCList != NULLIDX)
- break;
- /* If we can't get space for 5 mins we give up and panic */
- if (++downDCount > 300) {
-#if defined(AFS_CACHE_BYPASS)
- afs_warn("GetDCache calling osi_Panic: No space in five minutes.\n downDCount: %d\n aoffset: %d alen: %d\n", downDCount, aoffset, alen);
-#endif
- osi_Panic("getdcache");
- }
- MReleaseWriteLock(&afs_xdcache);
- /*
- * Locks held:
- * avc->lock(R) if setLocks
- * avc->lock(W) if !setLocks
- */
- afs_osi_Wait(1000, 0, 0);
- goto RetryLookup;
- }
+ if (dslot_error) {
+ /* We couldn't find the dcache we want, but we hit some i/o
+ * errors when trying to find it, so we're not sure if the
+ * dcache we want is in the cache or not. Error out, so we
+ * don't try to possibly create 2 separate dcaches for the
+ * same exact data. */
+ ReleaseWriteLock(&afs_xdcache);
+ goto done;
}
+ if (afs_discardDCList == NULLIDX && afs_freeDCList == NULLIDX) {
+ if (!setLocks)
+ avc->f.states |= CDCLock;
+ /* just need slots */
+ afs_GetDownD(5, (int *)0, afs_DCGetBucket(avc));
+ if (!setLocks)
+ avc->f.states &= ~CDCLock;
+ }
tdc = afs_AllocDCache(avc, chunk, aflags, NULL);
+ if (!tdc) {
+ /* If we can't get space for 5 mins we give up and panic */
+ if (++downDCount > 300)
+ osi_Panic("getdcache");
+ ReleaseWriteLock(&afs_xdcache);
+ /*
+ * Locks held:
+ * avc->lock(R) if setLocks
+ * avc->lock(W) if !setLocks
+ */
+ afs_osi_Wait(1000, 0, 0);
+ goto RetryLookup;
+ }
+
+ /*
+ * Locks held:
+ * avc->lock(R) if setLocks
+ * avc->lock(W) if !setLocks
+ * tdc->lock(W)
+ * afs_xdcache(W)
+ */
/*
* Now add to the two hash chains - note that i is still set
tdc->dflags = DFEntryMod;
tdc->mflags = 0;
afs_MaybeWakeupTruncateDaemon();
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
ConvertWToSLock(&tdc->lock);
}
}
#endif /* AFS_SGI_ENV */
if (AFS_CHUNKTOBASE(chunk) + adjustsize >= avc->f.m.Length &&
#else /* defined(AFS_AIX32_ENV) || defined(AFS_SGI_ENV) */
-#if defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV)
+#if defined(AFS_SUN5_ENV)
if ((doAdjustSize || (AFS_CHUNKTOBASE(chunk) >= avc->f.m.Length)) &&
#else
if (AFS_CHUNKTOBASE(chunk) >= avc->f.m.Length &&
if (doReallyAdjustSize || overWriteWholeChunk) {
/* no data in file to read at this position */
UpgradeSToWLock(&tdc->lock, 607);
-
-#if defined(LINUX_USE_FH)
- file = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
- file = afs_CFileOpen(tdc->f.inode);
-#endif
+ file = afs_CFileOpen(&tdc->f.inode);
afs_CFileTruncate(file, 0);
afs_CFileClose(file);
afs_AdjustSize(tdc, 0);
goto RetryGetDCache;
}
- /* Do not fetch data beyond truncPos. */
- maxGoodLength = avc->f.m.Length;
- if (avc->f.truncPos < maxGoodLength)
- maxGoodLength = avc->f.truncPos;
Position = AFS_CHUNKBASE(abyte);
if (vType(avc) == VDIR) {
size = avc->f.m.Length;
}
size = 999999999; /* max size for transfer */
} else {
+ afs_size_t maxGoodLength;
+
+ /* estimate how much data we're expecting back from the server,
+ * and reserve space in the dcache entry for it */
+
+ maxGoodLength = avc->f.m.Length;
+ if (avc->f.truncPos < maxGoodLength)
+ maxGoodLength = avc->f.truncPos;
+
size = AFS_CHUNKSIZE(abyte); /* expected max size */
- /* don't read past end of good data on server */
if (Position + size > maxGoodLength)
size = maxGoodLength - Position;
if (size < 0)
size = 0; /* Handle random races */
if (size > tdc->f.chunkBytes) {
- /* pre-reserve space for file */
+ /* pre-reserve estimated space for file */
afs_AdjustSize(tdc, size); /* changes chunkBytes */
- /* max size for transfer still in size */
+ }
+
+ if (size) {
+ /* For the actual fetch, do not limit the request to the
+ * length of the file. If this results in a read past EOF on
+ * the server, the server will just reply with less data than
+ * requested. If we limit ourselves to only requesting data up
+ * to the avc file length, we open ourselves up to races if the
+ * file is extended on the server at about the same time.
+ *
+ * However, we must restrict ourselves to the avc->f.truncPos
+ * length, since this represents an outstanding local
+ * truncation of the file that will be committed to the
+ * fileserver when we actually write the fileserver contents.
+ * If we do not restrict the fetch length based on
+ * avc->f.truncPos, a different truncate operation extending
+ * the file length could cause the old data after
+ * avc->f.truncPos to reappear, instead of extending the file
+ * with NUL bytes. */
+ size = AFS_CHUNKSIZE(abyte);
+ if (Position + size > avc->f.truncPos) {
+ size = avc->f.truncPos - Position;
+ }
+ if (size < 0) {
+ size = 0;
+ }
}
}
if (afs_mariner && !tdc->f.chunk)
* fetch the whole file.
*/
DZap(tdc); /* pages in cache may be old */
-#if defined(LINUX_USE_FH)
- file = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
- file = afs_CFileOpen(tdc->f.inode);
-#endif
+ file = afs_CFileOpen(&tdc->f.inode);
afs_RemoveVCB(&avc->f.fid);
tdc->f.states |= DWriting;
tdc->dflags |= DFFetching;
ICL_TYPE_POINTER, tdc, ICL_TYPE_INT32,
tdc->dflags);
}
- tsmall =
- (struct tlocal1 *)osi_AllocLargeSpace(sizeof(struct tlocal1));
+ tsmall = osi_AllocLargeSpace(sizeof(struct afs_FetchOutput));
setVcacheStatus = 0;
#ifndef AFS_NOSTATS
/*
* tdc->lock(W)
*/
- tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
+ tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
- afs_int32 length_hi, length, bytes;
#ifndef AFS_NOSTATS
numFetchLoops++;
if (fromReplica)
#endif /* AFS_NOSTATS */
if (!setLocks || slowPass) {
- avc->callback = tc->srvr->server;
+ avc->callback = tc->parent->srvr->server;
} else {
- newCallback = tc->srvr->server;
+ newCallback = tc->parent->srvr->server;
setNewCallback = 1;
}
i = osi_Time();
- RX_AFS_GUNLOCK();
- tcall = rx_NewCall(tc->id);
- RX_AFS_GLOCK();
-
- XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_FETCHDATA);
-#ifdef AFS_64BIT_CLIENT
- length_hi = code = 0;
- if (!afs_serverHasNo64Bit(tc)) {
- tsize = size;
- RX_AFS_GUNLOCK();
- code =
- StartRXAFS_FetchData64(tcall,
- (struct AFSFid *)&avc->f.fid.
- Fid, Position, tsize);
- if (code != 0) {
- RX_AFS_GLOCK();
- afs_Trace2(afs_iclSetp, CM_TRACE_FETCH64CODE,
- ICL_TYPE_POINTER, avc, ICL_TYPE_INT32,
- code);
- } else {
- bytes =
- rx_Read(tcall, (char *)&length_hi,
- sizeof(afs_int32));
- RX_AFS_GLOCK();
- if (bytes == sizeof(afs_int32)) {
- length_hi = ntohl(length_hi);
- } else {
- length_hi = 0;
- code = rx_Error(tcall);
- RX_AFS_GUNLOCK();
- code1 = rx_EndCall(tcall, code);
- RX_AFS_GLOCK();
- tcall = (struct rx_call *)0;
- }
- }
- }
- if (code == RXGEN_OPCODE || afs_serverHasNo64Bit(tc)) {
- if (Position > 0x7FFFFFFF) {
- code = EFBIG;
- } else {
- afs_int32 pos;
- pos = Position;
- RX_AFS_GUNLOCK();
- if (!tcall)
- tcall = rx_NewCall(tc->id);
- code =
- StartRXAFS_FetchData(tcall, (struct AFSFid *)
- &avc->f.fid.Fid, pos,
- size);
- RX_AFS_GLOCK();
- }
- afs_serverSetNo64Bit(tc);
- }
- if (code == 0) {
- RX_AFS_GUNLOCK();
- bytes =
- rx_Read(tcall, (char *)&length,
- sizeof(afs_int32));
- RX_AFS_GLOCK();
- if (bytes == sizeof(afs_int32)) {
- length = ntohl(length);
- } else {
- code = rx_Error(tcall);
- }
- }
- FillInt64(lengthFound, length_hi, length);
- afs_Trace3(afs_iclSetp, CM_TRACE_FETCH64LENG,
- ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code,
- ICL_TYPE_OFFSET,
- ICL_HANDLE_OFFSET(lengthFound));
-#else /* AFS_64BIT_CLIENT */
- RX_AFS_GUNLOCK();
- code =
- StartRXAFS_FetchData(tcall,
- (struct AFSFid *)&avc->f.fid.Fid,
- Position, size);
- RX_AFS_GLOCK();
- if (code == 0) {
- RX_AFS_GUNLOCK();
- bytes =
- rx_Read(tcall, (char *)&length,
- sizeof(afs_int32));
- RX_AFS_GLOCK();
- if (bytes == sizeof(afs_int32)) {
- length = ntohl(length);
- } else {
- code = rx_Error(tcall);
- }
- }
-#endif /* AFS_64BIT_CLIENT */
- if (code == 0) {
-
-#ifndef AFS_NOSTATS
- xferP =
- &(afs_stats_cmfullperf.rpc.
- fsXferTimes[AFS_STATS_FS_XFERIDX_FETCHDATA]);
- osi_GetuTime(&xferStartTime);
-
- code =
- afs_CacheFetchProc(tcall, file,
- (afs_size_t) Position, tdc,
- avc, &bytesToXfer,
- &bytesXferred, length);
-
- osi_GetuTime(&xferStopTime);
- (xferP->numXfers)++;
- if (!code) {
- (xferP->numSuccesses)++;
- afs_stats_XferSumBytes
- [AFS_STATS_FS_XFERIDX_FETCHDATA] +=
- bytesXferred;
- (xferP->sumBytes) +=
- (afs_stats_XferSumBytes
- [AFS_STATS_FS_XFERIDX_FETCHDATA] >> 10);
- afs_stats_XferSumBytes
- [AFS_STATS_FS_XFERIDX_FETCHDATA] &= 0x3FF;
- if (bytesXferred < xferP->minBytes)
- xferP->minBytes = bytesXferred;
- if (bytesXferred > xferP->maxBytes)
- xferP->maxBytes = bytesXferred;
-
- /*
- * Tally the size of the object. Note: we tally the actual size,
- * NOT the number of bytes that made it out over the wire.
- */
- if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET0)
- (xferP->count[0])++;
- else if (bytesToXfer <=
- AFS_STATS_MAXBYTES_BUCKET1)
- (xferP->count[1])++;
- else if (bytesToXfer <=
- AFS_STATS_MAXBYTES_BUCKET2)
- (xferP->count[2])++;
- else if (bytesToXfer <=
- AFS_STATS_MAXBYTES_BUCKET3)
- (xferP->count[3])++;
- else if (bytesToXfer <=
- AFS_STATS_MAXBYTES_BUCKET4)
- (xferP->count[4])++;
- else if (bytesToXfer <=
- AFS_STATS_MAXBYTES_BUCKET5)
- (xferP->count[5])++;
- else if (bytesToXfer <=
- AFS_STATS_MAXBYTES_BUCKET6)
- (xferP->count[6])++;
- else if (bytesToXfer <=
- AFS_STATS_MAXBYTES_BUCKET7)
- (xferP->count[7])++;
- else
- (xferP->count[8])++;
-
- afs_stats_GetDiff(elapsedTime, xferStartTime,
- xferStopTime);
- afs_stats_AddTo((xferP->sumTime), elapsedTime);
- afs_stats_SquareAddTo((xferP->sqrTime),
- elapsedTime);
- if (afs_stats_TimeLessThan
- (elapsedTime, (xferP->minTime))) {
- afs_stats_TimeAssign((xferP->minTime),
- elapsedTime);
- }
- if (afs_stats_TimeGreaterThan
- (elapsedTime, (xferP->maxTime))) {
- afs_stats_TimeAssign((xferP->maxTime),
- elapsedTime);
- }
- }
-#else
- code =
- afs_CacheFetchProc(tcall, file, Position, tdc,
- avc, 0, 0, length);
-#endif /* AFS_NOSTATS */
- }
- if (code == 0) {
- RX_AFS_GUNLOCK();
- code =
- EndRXAFS_FetchData(tcall, &tsmall->OutStatus,
- &tsmall->CallBack,
- &tsmall->tsync);
- RX_AFS_GLOCK();
- }
- XSTATS_END_TIME;
- RX_AFS_GUNLOCK();
- if (tcall)
- code1 = rx_EndCall(tcall, code);
- RX_AFS_GLOCK();
- } else {
- code = -1;
- }
- if (!code && code1)
- code = code1;
+ code = afs_CacheFetchProc(tc, rxconn, file, Position, tdc,
+ avc, size, tsmall);
+ } else
+ code = -1;
if (code == 0) {
- /* callback could have been broken (or expired) in a race here,
+ /* callback could have been broken (or expired) in a race here,
* but we return the data anyway. It's as good as we knew about
* when we started. */
- /*
- * validPos is updated by CacheFetchProc, and can only be
- * modifed under a dcache write lock, which we've blocked out
+ /*
+ * validPos is updated by CacheFetchProc, and can only be
+ * modifed under a dcache write lock, which we've blocked out
*/
size = tdc->validPos - Position; /* actual segment size */
if (size < 0)
}
} while (afs_Analyze
- (tc, code, &avc->f.fid, areq,
+ (tc, rxconn, code, &avc->f.fid, areq,
AFS_STATS_FS_RPCIDX_FETCHDATA, SHARED_LOCK, NULL));
/*
*/
osi_Assert(!setLocks || slowPass);
}
- tdc->f.states &= ~(DRO|DBackup|DRW);
- afs_DCMoveBucket(tdc, 0, 0);
tdc = NULL;
goto done;
}
/* Fix up LRU info */
if (tdc) {
- MObtainWriteLock(&afs_xdcache, 602);
+ ObtainWriteLock(&afs_xdcache, 602);
hset(afs_indexTimes[tdc->index], afs_indexCounter);
hadd32(afs_indexCounter, 1);
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
/* return the data */
if (vType(avc) == VDIR)
void
afs_WriteThroughDSlots(void)
{
- register struct dcache *tdc;
- register afs_int32 i, touchedit = 0;
+ struct dcache *tdc;
+ afs_int32 i, touchedit = 0;
struct afs_q DirtyQ, *tq;
* holding afs_xdcache. So we enter xdcache, get a reference
* for every dcache entry, and exit xdcache.
*/
- MObtainWriteLock(&afs_xdcache, 283);
+ ObtainWriteLock(&afs_xdcache, 283);
QInit(&DirtyQ);
for (i = 0; i < afs_cacheFiles; i++) {
tdc = afs_indexTable[i];
QAdd(&DirtyQ, &tdc->dirty);
}
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
/*
* Now, for each dcache entry we found, check if it's dirty.
/* Now that we have the write lock, double-check */
if (wrLock && (tdc->dflags & DFEntryMod)) {
tdc->dflags &= ~DFEntryMod;
- MObtainWriteLock(&afs_xdcache, 620);
- afs_WriteDCache(tdc, 1);
- MReleaseWriteLock(&afs_xdcache);
+ ObtainWriteLock(&afs_xdcache, 620);
+ osi_Assert(afs_WriteDCache(tdc, 1) == 0);
+ ReleaseWriteLock(&afs_xdcache);
touchedit = 1;
}
if (wrLock)
afs_PutDCache(tdc);
}
- MObtainWriteLock(&afs_xdcache, 617);
+ ObtainWriteLock(&afs_xdcache, 617);
if (!touchedit && (cacheDiskType != AFS_FCACHE_TYPE_MEM)) {
/* Touch the file to make sure that the mtime on the file is kept
* up-to-date to avoid losing cached files on cold starts because
theader.firstCSize = AFS_FIRSTCSIZE;
theader.otherCSize = AFS_OTHERCSIZE;
theader.version = AFS_CI_VERSION;
+ theader.dataSize = sizeof(struct fcache);
afs_osi_Write(afs_cacheInodep, 0, &theader, sizeof(theader));
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
}
/*
*
* Parameters:
* aslot : Dcache slot to look at.
- * tmpdc : Ptr to dcache entry.
+ * needvalid : Whether the specified slot should already exist
*
* Environment:
* Must be called with afs_xdcache write-locked.
*/
struct dcache *
-afs_MemGetDSlot(register afs_int32 aslot, register struct dcache *tmpdc)
+afs_MemGetDSlot(afs_int32 aslot, int indexvalid, int datavalid)
{
- register struct dcache *tdc;
+ struct dcache *tdc;
int existing = 0;
AFS_STATCNT(afs_MemGetDSlot);
ConvertWToRLock(&tdc->tlock);
return tdc;
}
- if (tmpdc == NULL) {
- if (!afs_freeDSList)
- afs_GetDownDSlot(4);
- if (!afs_freeDSList) {
- /* none free, making one is better than a panic */
- afs_stats_cmperf.dcacheXAllocs++; /* count in case we have a leak */
- tdc = (struct dcache *)afs_osi_Alloc(sizeof(struct dcache));
+
+ /* if 'indexvalid' is true, the slot must already exist and be populated
+ * somewhere. for memcache, the only place that dcache entries exist is
+ * in memory, so if we did not find it above, something is very wrong. */
+ osi_Assert(!indexvalid);
+
+ if (!afs_freeDSList)
+ afs_GetDownDSlot(4);
+ if (!afs_freeDSList) {
+ /* none free, making one is better than a panic */
+ afs_stats_cmperf.dcacheXAllocs++; /* count in case we have a leak */
+ tdc = afs_osi_Alloc(sizeof(struct dcache));
+ osi_Assert(tdc != NULL);
#ifdef KERNEL_HAVE_PIN
- pin((char *)tdc, sizeof(struct dcache)); /* XXX */
+ pin((char *)tdc, sizeof(struct dcache)); /* XXX */
#endif
- } else {
- tdc = afs_freeDSList;
- afs_freeDSList = (struct dcache *)tdc->lruq.next;
- existing = 1;
- }
- tdc->dflags = 0; /* up-to-date, not in free q */
- tdc->mflags = 0;
- QAdd(&afs_DLRU, &tdc->lruq);
- if (tdc->lruq.prev == &tdc->lruq)
- osi_Panic("lruq 3");
} else {
- tdc = tmpdc;
- tdc->f.states = 0;
+ tdc = afs_freeDSList;
+ afs_freeDSList = (struct dcache *)tdc->lruq.next;
+ existing = 1;
}
+ tdc->dflags = 0; /* up-to-date, not in free q */
+ tdc->mflags = 0;
+ QAdd(&afs_DLRU, &tdc->lruq);
+ if (tdc->lruq.prev == &tdc->lruq)
+ osi_Panic("lruq 3");
/* initialize entry */
tdc->f.fid.Cell = 0;
tdc->f.fid.Fid.Volume = 0;
tdc->f.chunk = -1;
hones(tdc->f.versionNo);
- tdc->f.inode = aslot;
+ tdc->f.inode.mem = aslot;
tdc->dflags |= DFEntryMod;
tdc->refCount = 1;
tdc->index = aslot;
AFS_RWLOCK_INIT(&tdc->mflock, "dcache flock");
ObtainReadLock(&tdc->tlock);
- if (tmpdc == NULL)
- afs_indexTable[aslot] = tdc;
+ afs_indexTable[aslot] = tdc;
return tdc;
} /*afs_MemGetDSlot */
*
* Parameters:
* aslot : Dcache slot to look at.
- * tmpdc : Ptr to dcache entry.
+ * indexvalid : 1 if we know the slot we're giving is valid, and thus
+ * reading the dcache from the disk index should succeed. 0
+ * if we are initializing a new dcache, and so reading from
+ * the disk index may fail.
+ * datavalid : 0 if we are loading a dcache entry from the free or
+ * discard list, so we know the data in the given dcache is
+ * not valid. 1 if we are loading a known used dcache, so the
+ * data in the dcache must be valid.
*
* Environment:
* afs_xdcache lock write-locked.
*/
struct dcache *
-afs_UFSGetDSlot(register afs_int32 aslot, register struct dcache *tmpdc)
+afs_UFSGetDSlot(afs_int32 aslot, int indexvalid, int datavalid)
{
- register afs_int32 code;
- register struct dcache *tdc;
+ afs_int32 code;
+ struct dcache *tdc;
int existing = 0;
int entryok;
+ int off;
AFS_STATCNT(afs_UFSGetDSlot);
if (CheckLock(&afs_xdcache) != -1)
ConvertWToRLock(&tdc->tlock);
return tdc;
}
+
/* otherwise we should read it in from the cache file */
- /*
- * If we weren't passed an in-memory region to place the file info,
- * we have to allocate one.
- */
- if (tmpdc == NULL) {
- if (!afs_freeDSList)
- afs_GetDownDSlot(4);
- if (!afs_freeDSList) {
- /* none free, making one is better than a panic */
- afs_stats_cmperf.dcacheXAllocs++; /* count in case we have a leak */
- tdc = (struct dcache *)afs_osi_Alloc(sizeof(struct dcache));
+ if (!afs_freeDSList)
+ afs_GetDownDSlot(4);
+ if (!afs_freeDSList) {
+ /* none free, making one is better than a panic */
+ afs_stats_cmperf.dcacheXAllocs++; /* count in case we have a leak */
+ tdc = afs_osi_Alloc(sizeof(struct dcache));
+ osi_Assert(tdc != NULL);
#ifdef KERNEL_HAVE_PIN
- pin((char *)tdc, sizeof(struct dcache)); /* XXX */
+ pin((char *)tdc, sizeof(struct dcache)); /* XXX */
#endif
- } else {
- tdc = afs_freeDSList;
- afs_freeDSList = (struct dcache *)tdc->lruq.next;
- existing = 1;
- }
- tdc->dflags = 0; /* up-to-date, not in free q */
- tdc->mflags = 0;
- QAdd(&afs_DLRU, &tdc->lruq);
- if (tdc->lruq.prev == &tdc->lruq)
- osi_Panic("lruq 3");
} else {
- tdc = tmpdc;
- tdc->f.states = 0;
+ tdc = afs_freeDSList;
+ afs_freeDSList = (struct dcache *)tdc->lruq.next;
+ existing = 1;
}
+ tdc->dflags = 0; /* up-to-date, not in free q */
+ tdc->mflags = 0;
+ QAdd(&afs_DLRU, &tdc->lruq);
+ if (tdc->lruq.prev == &tdc->lruq)
+ osi_Panic("lruq 3");
/*
* Seek to the aslot'th entry and read it in.
*/
+ off = sizeof(struct fcache)*aslot + sizeof(struct afs_fheader);
code =
afs_osi_Read(afs_cacheInodep,
- sizeof(struct fcache) * aslot +
- sizeof(struct afs_fheader), (char *)(&tdc->f),
+ off, (char *)(&tdc->f),
sizeof(struct fcache));
entryok = 1;
- if (code != sizeof(struct fcache))
+ if (code != sizeof(struct fcache)) {
entryok = 0;
- if (!afs_CellNumValid(tdc->f.fid.Cell))
+#if defined(KERNEL_HAVE_UERROR)
+ last_error = getuerror();
+#else
+ last_error = code;
+#endif
+ lasterrtime = osi_Time();
+ if (indexvalid) {
+ struct osi_stat tstat;
+ if (afs_osi_Stat(afs_cacheInodep, &tstat)) {
+ tstat.size = -1;
+ }
+ afs_warn("afs: disk cache read error in CacheItems slot %d "
+ "off %d/%d code %d/%d\n",
+ (int)aslot,
+ off, (int)tstat.size,
+ (int)code, (int)sizeof(struct fcache));
+ /* put tdc back on the free dslot list */
+ QRemove(&tdc->lruq);
+ tdc->index = NULLIDX;
+ tdc->lruq.next = (struct afs_q *)afs_freeDSList;
+ afs_freeDSList = tdc;
+ return NULL;
+ }
+ }
+ if (!afs_CellNumValid(tdc->f.fid.Cell)) {
entryok = 0;
+ if (datavalid) {
+ osi_Panic("afs: needed valid dcache but index %d off %d has "
+ "invalid cell num %d\n",
+ (int)aslot, off, (int)tdc->f.fid.Cell);
+ }
+ }
+
+ if (datavalid && tdc->f.fid.Fid.Volume == 0) {
+ osi_Panic("afs: invalid zero-volume dcache entry at slot %d off %d",
+ (int)aslot, off);
+ }
+
+ if (indexvalid && !datavalid) {
+ /* we know that the given dslot does exist, but the data in it is not
+ * valid. this only occurs when we pull a dslot from the free or
+ * discard list, so be sure not to re-use the data; force invalidation.
+ */
+ entryok = 0;
+ }
if (!entryok) {
tdc->f.fid.Cell = 0;
tdc->f.chunk = -1;
hones(tdc->f.versionNo);
tdc->dflags |= DFEntryMod;
-#if defined(KERNEL_HAVE_UERROR)
- last_error = getuerror();
-#endif
- lasterrtime = osi_Time();
afs_indexUnique[aslot] = tdc->f.fid.Fid.Unique;
tdc->f.states &= ~(DRO|DBackup|DRW);
afs_DCMoveBucket(tdc, 0, 0);
} else if (tdc->f.states & DBackup) {
afs_DCMoveBucket(tdc, 0, 1);
} else {
- afs_DCMoveBucket(tdc, 0, 1);
+ afs_DCMoveBucket(tdc, 0, 1);
}
- }
+ }
}
tdc->refCount = 1;
tdc->index = aslot;
* If we didn't read into a temporary dcache region, update the
* slot pointer table.
*/
- if (tmpdc == NULL)
- afs_indexTable[aslot] = tdc;
+ afs_indexTable[aslot] = tdc;
return tdc;
} /*afs_UFSGetDSlot */
*/
int
-afs_WriteDCache(register struct dcache *adc, int atime)
+afs_WriteDCache(struct dcache *adc, int atime)
{
- register afs_int32 code;
+ afs_int32 code;
if (cacheDiskType == AFS_FCACHE_TYPE_MEM)
return 0;
osi_Assert(WriteLocked(&afs_xdcache));
if (atime)
adc->f.modTime = osi_Time();
+
+ if ((afs_indexFlags[adc->index] & (IFFree | IFDiscarded)) == 0 &&
+ adc->f.fid.Fid.Volume == 0) {
+ /* If a dcache slot is not on the free or discard list, it must be
+ * in the hash table. Thus, the volume must be non-zero, since that
+ * is how we determine whether or not to unhash the entry when kicking
+ * it out of the cache. Do this check now, since otherwise this can
+ * cause hash table corruption and a panic later on after we read the
+ * entry back in. */
+ osi_Panic("afs_WriteDCache zero volume index %d flags 0x%x\n",
+ adc->index, (unsigned)afs_indexFlags[adc->index]);
+ }
+
/*
* Seek to the right dcache slot and write the in-memory image out to disk.
*/
sizeof(struct fcache) * adc->index +
sizeof(struct afs_fheader), (char *)(&adc->f),
sizeof(struct fcache));
- if (code != sizeof(struct fcache))
+ if (code != sizeof(struct fcache)) {
+ afs_warn("afs: failed to write to CacheItems off %ld code %d/%d\n",
+ (long)(sizeof(struct fcache) * adc->index + sizeof(struct afs_fheader)),
+ (int)code, (int)sizeof(struct fcache));
return EIO;
+ }
return 0;
}
* Nothing interesting.
*/
int
-afs_wakeup(register struct vcache *avc)
+afs_wakeup(struct vcache *avc)
{
- register int i;
- register struct brequest *tb;
+ int i;
+ struct brequest *tb;
tb = afs_brs;
AFS_STATCNT(afs_wakeup);
for (i = 0; i < NBRS; i++, tb++) {
return 0;
}
-
/*!
* Given a file name and inode, set up that file to be an
* active member in the AFS cache. This also involves checking
int
afs_InitCacheFile(char *afile, ino_t ainode)
{
- register afs_int32 code;
-#if defined(AFS_LINUX22_ENV)
- struct dentry *filevp;
-#else
- struct vnode *filevp;
-#endif
+ afs_int32 code;
afs_int32 index;
int fileIsBad;
struct osi_file *tfile;
struct osi_stat tstat;
- register struct dcache *tdc;
-#if defined(LINUX_USE_FH)
- int max_len = sizeof(struct fid);
-#endif
+ struct dcache *tdc;
AFS_STATCNT(afs_InitCacheFile);
index = afs_stats_cmperf.cacheNumEntries;
if (index >= afs_cacheFiles)
return EINVAL;
- MObtainWriteLock(&afs_xdcache, 282);
- tdc = afs_GetDSlot(index, NULL);
+ ObtainWriteLock(&afs_xdcache, 282);
+ tdc = afs_GetNewDSlot(index);
ReleaseReadLock(&tdc->tlock);
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
ObtainWriteLock(&tdc->lock, 621);
- MObtainWriteLock(&afs_xdcache, 622);
- if (afile) {
- code = gop_lookupname(afile, AFS_UIOSYS, 0, &filevp);
- if (code) {
- ReleaseWriteLock(&afs_xdcache);
- ReleaseWriteLock(&tdc->lock);
- afs_PutDCache(tdc);
- return code;
- }
- /*
- * We have a VN_HOLD on filevp. Get the useful info out and
- * return. We make use of the fact that the cache is in the
- * UFS file system, and just record the inode number.
- */
-#ifdef AFS_LINUX22_ENV
-#if defined(LINUX_USE_FH)
- tdc->f.fh_type = osi_get_fh(filevp, &tdc->f.fh, &max_len);
-#else
- tdc->f.inode = VTOI(filevp->d_inode)->i_number;
- dput(filevp);
-#endif
-#else
- tdc->f.inode = afs_vnodeToInumber(filevp);
- AFS_RELE(filevp);
-#endif /* AFS_LINUX22_ENV */
- } else {
- tdc->f.inode = ainode;
- }
- fileIsBad = 0;
- if ((tdc->f.states & DWriting) || tdc->f.fid.Fid.Volume == 0)
+ ObtainWriteLock(&afs_xdcache, 622);
+ if (!afile && !ainode) {
+ tfile = NULL;
fileIsBad = 1;
-#if defined(LINUX_USE_FH)
- tfile = osi_UFSOpen_fh(&tdc->f.fh, tdc->f.fh_type);
+ } else {
+ if (afile) {
+ code = afs_LookupInodeByPath(afile, &tdc->f.inode.ufs, NULL);
+ if (code) {
+ ReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&tdc->lock);
+ afs_PutDCache(tdc);
+ return code;
+ }
+ } else {
+ /* Add any other 'complex' inode types here ... */
+#if !defined(AFS_LINUX26_ENV) && !defined(AFS_CACHE_VNODE_PATH)
+ tdc->f.inode.ufs = ainode;
#else
- tfile = osi_UFSOpen(tdc->f.inode);
+ osi_Panic("Can't init cache with inode numbers when complex inodes are "
+ "in use\n");
#endif
- code = afs_osi_Stat(tfile, &tstat);
- if (code)
- osi_Panic("initcachefile stat");
+ }
+ fileIsBad = 0;
+ if ((tdc->f.states & DWriting) || tdc->f.fid.Fid.Volume == 0)
+ fileIsBad = 1;
+ tfile = osi_UFSOpen(&tdc->f.inode);
+ code = afs_osi_Stat(tfile, &tstat);
+ if (code)
+ osi_Panic("initcachefile stat");
- /*
- * If file size doesn't match the cache info file, it's probably bad.
- */
- if (tdc->f.chunkBytes != tstat.size)
- fileIsBad = 1;
+ /*
+ * If file size doesn't match the cache info file, it's probably bad.
+ */
+ if (tdc->f.chunkBytes != tstat.size)
+ fileIsBad = 1;
+ /*
+ * If file changed within T (120?) seconds of cache info file, it's
+ * probably bad. In addition, if slot changed within last T seconds,
+ * the cache info file may be incorrectly identified, and so slot
+ * may be bad.
+ */
+ if (cacheInfoModTime < tstat.mtime + 120)
+ fileIsBad = 1;
+ if (cacheInfoModTime < tdc->f.modTime + 120)
+ fileIsBad = 1;
+ /* In case write through is behind, make sure cache items entry is
+ * at least as new as the chunk.
+ */
+ if (tdc->f.modTime < tstat.mtime)
+ fileIsBad = 1;
+ }
tdc->f.chunkBytes = 0;
- /*
- * If file changed within T (120?) seconds of cache info file, it's
- * probably bad. In addition, if slot changed within last T seconds,
- * the cache info file may be incorrectly identified, and so slot
- * may be bad.
- */
- if (cacheInfoModTime < tstat.mtime + 120)
- fileIsBad = 1;
- if (cacheInfoModTime < tdc->f.modTime + 120)
- fileIsBad = 1;
- /* In case write through is behind, make sure cache items entry is
- * at least as new as the chunk.
- */
- if (tdc->f.modTime < tstat.mtime)
- fileIsBad = 1;
if (fileIsBad) {
tdc->f.fid.Fid.Volume = 0; /* not in the hash table */
- if (tstat.size != 0)
+ if (tfile && tstat.size != 0)
osi_UFSTruncate(tfile, 0);
tdc->f.states &= ~(DRO|DBackup|DRW);
afs_DCMoveBucket(tdc, 0, 0);
afs_indexUnique[index] = tdc->f.fid.Fid.Unique;
} /*File is not bad */
- osi_UFSClose(tfile);
+ if (tfile)
+ osi_UFSClose(tfile);
tdc->f.states &= ~DWriting;
tdc->dflags &= ~DFEntryMod;
/* don't set f.modTime; we're just cleaning up */
- afs_WriteDCache(tdc, 0);
+ osi_Assert(afs_WriteDCache(tdc, 0) == 0);
ReleaseWriteLock(&afs_xdcache);
ReleaseWriteLock(&tdc->lock);
afs_PutDCache(tdc);
* Initialize dcache related variables.
*
* \param afiles
- * \param ablocks
+ * \param ablocks
* \param aDentries
* \param achunk
* \param aflags
void
afs_dcacheInit(int afiles, int ablocks, int aDentries, int achunk, int aflags)
{
- register struct dcache *tdp;
+ struct dcache *tdp;
int i;
int code;
if (!aDentries)
aDentries = DDSIZE;
- if (aflags & AFSCALL_INIT_MEMCACHE) {
- /*
- * Use a memory cache instead of a disk cache
- */
- cacheDiskType = AFS_FCACHE_TYPE_MEM;
- afs_cacheType = &afs_MemCacheOps;
- afiles = (afiles < aDentries) ? afiles : aDentries; /* min */
- ablocks = afiles * (AFS_FIRSTCSIZE / 1024);
- /* ablocks is reported in 1K blocks */
- code = afs_InitMemCache(afiles, AFS_FIRSTCSIZE, aflags);
- if (code != 0) {
- printf("afsd: memory cache too large for available memory.\n");
- printf("afsd: AFS files cannot be accessed.\n\n");
- dcacheDisabled = 1;
- afiles = ablocks = 0;
- } else
- printf("Memory cache: Allocating %d dcache entries...",
- aDentries);
- } else {
- cacheDiskType = AFS_FCACHE_TYPE_UFS;
- afs_cacheType = &afs_UfsCacheOps;
- }
-
if (aDentries > 512)
afs_dhashsize = 2048;
/* initialize hash tables */
- afs_dvhashTbl =
- (afs_int32 *) afs_osi_Alloc(afs_dhashsize * sizeof(afs_int32));
- afs_dchashTbl =
- (afs_int32 *) afs_osi_Alloc(afs_dhashsize * sizeof(afs_int32));
+ afs_dvhashTbl = afs_osi_Alloc(afs_dhashsize * sizeof(afs_int32));
+ osi_Assert(afs_dvhashTbl != NULL);
+ afs_dchashTbl = afs_osi_Alloc(afs_dhashsize * sizeof(afs_int32));
+ osi_Assert(afs_dchashTbl != NULL);
for (i = 0; i < afs_dhashsize; i++) {
afs_dvhashTbl[i] = NULLIDX;
afs_dchashTbl[i] = NULLIDX;
}
- afs_dvnextTbl = (afs_int32 *) afs_osi_Alloc(afiles * sizeof(afs_int32));
- afs_dcnextTbl = (afs_int32 *) afs_osi_Alloc(afiles * sizeof(afs_int32));
+ afs_dvnextTbl = afs_osi_Alloc(afiles * sizeof(afs_int32));
+ osi_Assert(afs_dvnextTbl != NULL);
+ afs_dcnextTbl = afs_osi_Alloc(afiles * sizeof(afs_int32));
+ osi_Assert(afs_dcnextTbl != NULL);
for (i = 0; i < afiles; i++) {
afs_dvnextTbl[i] = NULLIDX;
afs_dcnextTbl[i] = NULLIDX;
}
/* Allocate and zero the pointer array to the dcache entries */
- afs_indexTable = (struct dcache **)
- afs_osi_Alloc(sizeof(struct dcache *) * afiles);
- memset((char *)afs_indexTable, 0, sizeof(struct dcache *) * afiles);
- afs_indexTimes =
- (afs_hyper_t *) afs_osi_Alloc(afiles * sizeof(afs_hyper_t));
- memset((char *)afs_indexTimes, 0, afiles * sizeof(afs_hyper_t));
- afs_indexUnique =
- (afs_int32 *) afs_osi_Alloc(afiles * sizeof(afs_uint32));
- memset((char *)afs_indexUnique, 0, afiles * sizeof(afs_uint32));
- afs_indexFlags = (u_char *) afs_osi_Alloc(afiles * sizeof(u_char));
- memset((char *)afs_indexFlags, 0, afiles * sizeof(char));
+ afs_indexTable = afs_osi_Alloc(sizeof(struct dcache *) * afiles);
+ osi_Assert(afs_indexTable != NULL);
+ memset(afs_indexTable, 0, sizeof(struct dcache *) * afiles);
+ afs_indexTimes = afs_osi_Alloc(afiles * sizeof(afs_hyper_t));
+ osi_Assert(afs_indexTimes != NULL);
+ memset(afs_indexTimes, 0, afiles * sizeof(afs_hyper_t));
+ afs_indexUnique = afs_osi_Alloc(afiles * sizeof(afs_uint32));
+ osi_Assert(afs_indexUnique != NULL);
+ memset(afs_indexUnique, 0, afiles * sizeof(afs_uint32));
+ afs_indexFlags = afs_osi_Alloc(afiles * sizeof(u_char));
+ osi_Assert(afs_indexFlags != NULL);
+ memset(afs_indexFlags, 0, afiles * sizeof(char));
/* Allocate and thread the struct dcache entries themselves */
tdp = afs_Initial_freeDSList =
- (struct dcache *)afs_osi_Alloc(aDentries * sizeof(struct dcache));
- memset((char *)tdp, 0, aDentries * sizeof(struct dcache));
+ afs_osi_Alloc(aDentries * sizeof(struct dcache));
+ osi_Assert(tdp != NULL);
+ memset(tdp, 0, aDentries * sizeof(struct dcache));
#ifdef KERNEL_HAVE_PIN
pin((char *)afs_indexTable, sizeof(struct dcache *) * afiles); /* XXX */
pin((char *)afs_indexTimes, sizeof(afs_hyper_t) * afiles); /* XXX */
afs_dcentries = aDentries;
afs_blocksUsed = 0;
- afs_stats_cmperf.cacheBucket0_Discarded =
- afs_stats_cmperf.cacheBucket1_Discarded =
+ afs_stats_cmperf.cacheBucket0_Discarded =
+ afs_stats_cmperf.cacheBucket1_Discarded =
afs_stats_cmperf.cacheBucket2_Discarded = 0;
afs_DCSizeInit();
QInit(&afs_DLRU);
+
+ if (aflags & AFSCALL_INIT_MEMCACHE) {
+ /*
+ * Use a memory cache instead of a disk cache
+ */
+ cacheDiskType = AFS_FCACHE_TYPE_MEM;
+ afs_cacheType = &afs_MemCacheOps;
+ afiles = (afiles < aDentries) ? afiles : aDentries; /* min */
+ ablocks = afiles * (AFS_FIRSTCSIZE / 1024);
+ /* ablocks is reported in 1K blocks */
+ code = afs_InitMemCache(afiles, AFS_FIRSTCSIZE, aflags);
+ if (code != 0) {
+ afs_warn("afsd: memory cache too large for available memory.\n");
+ afs_warn("afsd: AFS files cannot be accessed.\n\n");
+ dcacheDisabled = 1;
+ } else
+ afs_warn("Memory cache: Allocating %d dcache entries...",
+ aDentries);
+ } else {
+ cacheDiskType = AFS_FCACHE_TYPE_UFS;
+ afs_cacheType = &afs_UfsCacheOps;
+ }
}
/*!
{
int i;
+#ifdef AFS_CACHE_VNODE_PATH
+ if (cacheDiskType != AFS_FCACHE_TYPE_MEM) {
+ struct dcache *tdc;
+ for (i = 0; i < afs_cacheFiles; i++) {
+ tdc = afs_indexTable[i];
+ if (tdc) {
+ afs_osi_FreeStr(tdc->f.inode.ufs);
+ }
+ }
+ }
+#endif
+
afs_osi_Free(afs_dvnextTbl, afs_cacheFiles * sizeof(afs_int32));
afs_osi_Free(afs_dcnextTbl, afs_cacheFiles * sizeof(afs_int32));
afs_osi_Free(afs_indexTable, afs_cacheFiles * sizeof(struct dcache *));
afs_osi_Free(afs_dchashTbl, afs_dhashsize * sizeof(afs_int32));
afs_blocksUsed = afs_dcentries = 0;
- afs_stats_cmperf.cacheBucket0_Discarded =
- afs_stats_cmperf.cacheBucket1_Discarded =
+ afs_stats_cmperf.cacheBucket0_Discarded =
+ afs_stats_cmperf.cacheBucket1_Discarded =
afs_stats_cmperf.cacheBucket2_Discarded = 0;
hzero(afs_indexCounter);
/*!
* Get a dcache ready for writing, respecting the current cache size limits
*
- * len is required because afs_GetDCache with flag == 4 expects the length
- * field to be filled. It decides from this whether it's necessary to fetch
- * data into the chunk before writing or not (when the whole chunk is
+ * len is required because afs_GetDCache with flag == 4 expects the length
+ * field to be filled. It decides from this whether it's necessary to fetch
+ * data into the chunk before writing or not (when the whole chunk is
* overwritten!).
*
* \param avc The vcache to fetch a dcache for
* \param noLock
*
* \return If successful, a reference counted dcache with tdc->lock held. Lock
- * must be released and afs_PutDCache() called to free dcache.
+ * must be released and afs_PutDCache() called to free dcache.
* NULL on failure
*
- * \note avc->lock must be held on entry. Function may release and reobtain
+ * \note avc->lock must be held on entry. Function may release and reobtain
* avc->lock and GLOCK.
*/
struct dcache *
-afs_ObtainDCacheForWriting(struct vcache *avc, afs_size_t filePos,
+afs_ObtainDCacheForWriting(struct vcache *avc, afs_size_t filePos,
afs_size_t len, struct vrequest *areq,
- int noLock) {
+ int noLock)
+{
struct dcache *tdc = NULL;
afs_size_t offset;
return tdc;
}
-#if defined(AFS_DISCON_ENV)
-
/*!
* Make a shadow copy of a dir's dcache. It's used for disconnected
* operations like remove/create/rename to keep the original directory data.
* \note The vcache entry must be write locked.
* \note The dcache entry must be read locked.
*/
-int afs_MakeShadowDir(struct vcache *avc, struct dcache *adc)
+int
+afs_MakeShadowDir(struct vcache *avc, struct dcache *adc)
{
int i, code, ret_code = 0, written, trans_size;
struct dcache *new_dc = NULL;
struct osi_file *tfile_src, *tfile_dst;
struct VenusFid shadow_fid;
char *data;
- int lock_held = 0;
/* Is this a dir? */
if (vType(avc) != VDIR)
/* Get a fresh dcache. */
new_dc = afs_AllocDCache(avc, 0, 0, &shadow_fid);
+ osi_Assert(new_dc);
ObtainReadLock(&adc->mflock);
new_dc->f.chunkBytes = adc->f.chunkBytes;
ReleaseReadLock(&adc->mflock);
-
+
/* Now add to the two hash chains */
i = DCHash(&shadow_fid, 0);
afs_dcnextTbl[new_dc->index] = afs_dchashTbl[i];
ReleaseWriteLock(&afs_xdcache);
/* Alloc a 4k block. */
- data = (char *) afs_osi_Alloc(4096);
+ data = afs_osi_Alloc(4096);
if (!data) {
- printf("afs_MakeShadowDir: could not alloc data\n");
+ afs_warn("afs_MakeShadowDir: could not alloc data\n");
ret_code = ENOMEM;
goto done;
}
/* Open the files. */
- tfile_src = afs_CFileOpen(adc->f.inode);
- tfile_dst = afs_CFileOpen(new_dc->f.inode);
+ tfile_src = afs_CFileOpen(&adc->f.inode);
+ tfile_dst = afs_CFileOpen(&new_dc->f.inode);
/* And now copy dir dcache data into this dcache,
* 4k at a time.
ObtainWriteLock(&afs_xvcache, 763);
ObtainWriteLock(&afs_disconDirtyLock, 765);
QAdd(&afs_disconShadow, &avc->shadowq);
- osi_vnhold(avc, 0);
+ osi_Assert((afs_RefVCache(avc) == 0));
ReleaseWriteLock(&afs_disconDirtyLock);
ReleaseWriteLock(&afs_xvcache);
*
* \note avc must be write locked.
*/
-void afs_DeleteShadowDir(struct vcache *avc)
+void
+afs_DeleteShadowDir(struct vcache *avc)
{
struct dcache *tdc;
struct VenusFid shadow_fid;
* \param alen The new length of the file
*
*/
-void afs_PopulateDCache(struct vcache *avc, afs_size_t apos, struct vrequest *areq) {
+void
+afs_PopulateDCache(struct vcache *avc, afs_size_t apos, struct vrequest *areq)
+{
struct dcache *tdc;
afs_size_t len, offset;
afs_int32 start, end;
/* We're doing this to deal with the situation where we extend
- * by writing after lseek()ing past the end of the file . If that
- * extension skips chunks, then those chunks won't be created, and
- * GetDCache will assume that they have to be fetched from the server.
- * So, for each chunk between the current file position, and the new
+ * by writing after lseek()ing past the end of the file . If that
+ * extension skips chunks, then those chunks won't be created, and
+ * GetDCache will assume that they have to be fetched from the server.
+ * So, for each chunk between the current file position, and the new
* length we GetDCache for that chunk.
*/
- if (AFS_CHUNK(apos) == 0 || apos <= avc->f.m.Length)
+ if (AFS_CHUNK(apos) == 0 || apos <= avc->f.m.Length)
return;
if (avc->f.m.Length == 0)
start = 0;
- else
+ else
start = AFS_CHUNK(avc->f.m.Length)+1;
end = AFS_CHUNK(apos);
start++;
}
}
-
-#endif