src/afs/afs_dcache.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * Implements:
  12  */
  13 #include <afsconfig.h>
  14 #include "../afs/param.h"
  15
  16 RCSID("$Header$");
  17
  18 #include "../afs/sysincludes.h" /*Standard vendor system headers*/
  19 #include "../afs/afsincludes.h" /*AFS-based standard headers*/
  20 #include "../afs/afs_stats.h"  /* statistics */
  21 #include "../afs/afs_cbqueue.h"
  22 #include "../afs/afs_osidnlc.h"
  23
  24 /* Forward declarations. */
  25 static void afs_GetDownD(int anumber, int *aneedSpace);
  26 static void afs_FreeDiscardedDCache(void);
  27 static void afs_DiscardDCache(struct dcache *);
  28 static void afs_FreeDCache(struct dcache *);
  29
  30 /*
  31  * --------------------- Exported definitions ---------------------
  32  */
  33 afs_lock_t afs_xdcache;                 /*Lock: alloc new disk cache entries*/
  34 afs_int32 afs_freeDCList;               /*Free list for disk cache entries*/
  35 afs_int32 afs_freeDCCount;              /*Count of elts in freeDCList*/
  36 afs_int32 afs_discardDCList;            /*Discarded disk cache entries*/
  37 afs_int32 afs_discardDCCount;           /*Count of elts in discardDCList*/
  38 struct dcache *afs_freeDSList;          /*Free list for disk slots */
  39 struct dcache *afs_Initial_freeDSList;  /*Initial list for above*/
  40 ino_t cacheInode;                       /*Inode for CacheItems file*/
  41 struct osi_file *afs_cacheInodep = 0;   /* file for CacheItems inode */
  42 struct afs_q afs_DLRU;                  /*dcache LRU*/
  43 afs_int32 afs_dhashsize = 1024;
  44 afs_int32 *afs_dvhashTbl;               /*Data cache hash table*/
  45 afs_int32 *afs_dchashTbl;               /*Data cache hash table*/
  46 afs_int32 *afs_dvnextTbl;               /*Dcache hash table links */
  47 afs_int32 *afs_dcnextTbl;               /*Dcache hash table links */
  48 struct dcache **afs_indexTable;         /*Pointers to dcache entries*/
  49 afs_hyper_t *afs_indexTimes;            /*Dcache entry Access times*/
  50 afs_int32 *afs_indexUnique;             /*dcache entry Fid.Unique */
  51 unsigned char *afs_indexFlags;          /*(only one) Is there data there?*/
  52 afs_hyper_t afs_indexCounter;           /*Fake time for marking index
  53                                           entries*/
  54 afs_int32 afs_cacheFiles =0;            /*Size of afs_indexTable*/
  55 afs_int32 afs_cacheBlocks;              /*1K blocks in cache*/
  56 afs_int32 afs_cacheStats;               /*Stat entries in cache*/
  57 afs_int32 afs_blocksUsed;               /*Number of blocks in use*/
  58 afs_int32 afs_blocksDiscarded;          /*Blocks freed but not truncated */
  59 afs_int32 afs_fsfragsize = 1023;        /*Underlying Filesystem minimum unit
  60                                          *of disk allocation usually 1K
  61                                          *this value is (truefrag -1 ) to
  62                                          *save a bunch of subtracts... */
  63 #ifdef AFS_64BIT_CLIENT
  64 #ifdef AFS_VM_RDWR_ENV
  65 afs_size_t afs_vmMappingEnd;            /* for large files (>= 2GB) the VM
  66                                          * mapping an 32bit addressing machines
  67                                          * can only be used below the 2 GB
  68                                          * line. From this point upwards we
  69                                          * must do direct I/O into the cache
  70                                          * files. The value should be on a
  71                                          * chunk boundary. */
  72 #endif /* AFS_VM_RDWR_ENV */
  73 #endif /* AFS_64BIT_CLIENT */
  74
  75 /* The following is used to ensure that new dcache's aren't obtained when
  76  * the cache is nearly full.
  77  */
  78 int afs_WaitForCacheDrain = 0;
  79 int afs_TruncateDaemonRunning = 0;
  80 int afs_CacheTooFull = 0;
  81
  82 afs_int32  afs_dcentries;               /* In-memory dcache entries */
  83
  84
  85 int dcacheDisabled = 0;
  86
  87 extern struct dcache *afs_UFSGetDSlot();
  88 extern struct volume *afs_UFSGetVolSlot();
  89 extern int osi_UFSTruncate(), afs_osi_Read(), afs_osi_Write(), osi_UFSClose();
  90 extern int afs_UFSRead(), afs_UFSWrite();
  91 extern int afs_UFSHandleLink();
  92 static int afs_UFSCacheFetchProc(), afs_UFSCacheStoreProc();
  93 struct afs_cacheOps afs_UfsCacheOps = {
  94     osi_UFSOpen,
  95     osi_UFSTruncate,
  96     afs_osi_Read,
  97     afs_osi_Write,
  98     osi_UFSClose,
  99     afs_UFSRead,
 100     afs_UFSWrite,
 101     afs_UFSCacheFetchProc,
 102     afs_UFSCacheStoreProc,
 103     afs_UFSGetDSlot,
 104     afs_UFSGetVolSlot,
 105     afs_UFSHandleLink,
 106 };
 107
 108 struct afs_cacheOps afs_MemCacheOps = {
 109     afs_MemCacheOpen,
 110     afs_MemCacheTruncate,
 111     afs_MemReadBlk,
 112     afs_MemWriteBlk,
 113     afs_MemCacheClose,
 114     afs_MemRead,
 115     afs_MemWrite,
 116     afs_MemCacheFetchProc,
 117     afs_MemCacheStoreProc,
 118     afs_MemGetDSlot,
 119     afs_MemGetVolSlot,
 120     afs_MemHandleLink,
 121 };
 122
 123 int cacheDiskType;                      /*Type of backing disk for cache*/
 124 struct afs_cacheOps *afs_cacheType;
 125
 126
 127
 128
 129 /*
 130  * afs_StoreWarn
 131  *
 132  * Description:
 133  *      Warn about failing to store a file.
 134  *
 135  * Parameters:
 136  *      acode   : Associated error code.
 137  *      avolume : Volume involved.
 138  *      aflags  : How to handle the output:
 139  *                      aflags & 1: Print out on console
 140  *                      aflags & 2: Print out on controlling tty
 141  *
 142  * Environment:
 143  *      Call this from close call when vnodeops is RCS unlocked.
 144  */
 145
 146 void afs_StoreWarn(register afs_int32 acode, afs_int32 avolume, register afs_int32 aflags)
 147 {
 148     static char problem_fmt[] =
 149         "afs: failed to store file in volume %d (%s)\n";
 150     static char problem_fmt_w_error[] =
 151         "afs: failed to store file in volume %d (error %d)\n";
 152     static char netproblems[] = "network problems";
 153     static char partfull[]    = "partition full";
 154     static char overquota[]   = "over quota";
 155
 156     AFS_STATCNT(afs_StoreWarn);
 157     if (acode < 0) {
 158         /*
 159          * Network problems
 160          */
 161         if (aflags & 1)
 162             afs_warn(problem_fmt, avolume, netproblems);
 163         if (aflags & 2)
 164             afs_warnuser(problem_fmt, avolume, netproblems);
 165     }
 166     else
 167         if (acode == ENOSPC) {
 168             /*
 169              * Partition full
 170              */
 171             if (aflags & 1)
 172                 afs_warn(problem_fmt, avolume, partfull);
 173             if (aflags & 2)
 174                 afs_warnuser(problem_fmt, avolume, partfull);
 175         }
 176         else
 177 #ifndef AFS_SUN5_ENV
 178             /* EDQUOT doesn't exist on solaris and won't be sent by the server.
 179              * Instead ENOSPC will be sent...
 180              */
 181             if (acode == EDQUOT) {
 182                 /*
 183                  * Quota exceeded
 184                  */
 185                 if (aflags & 1)
 186                     afs_warn(problem_fmt, avolume, overquota);
 187                 if (aflags & 2)
 188                     afs_warnuser(problem_fmt, avolume, overquota);
 189             } else
 190 #endif
 191             {
 192                 /*
 193                  * Unknown error
 194                  */
 195                 if (aflags & 1)
 196                     afs_warn(problem_fmt_w_error, avolume, acode);
 197                 if (aflags & 2)
 198                     afs_warnuser(problem_fmt_w_error, avolume, acode);
 199             }
 200 } /*afs_StoreWarn*/
 201
 202 void afs_MaybeWakeupTruncateDaemon(void)
 203 {
 204     if (!afs_CacheTooFull && afs_CacheIsTooFull()) {
 205         afs_CacheTooFull = 1;
 206         if (!afs_TruncateDaemonRunning)
 207             afs_osi_Wakeup((int *)afs_CacheTruncateDaemon);
 208     } else if (!afs_TruncateDaemonRunning &&
 209                 afs_blocksDiscarded > CM_MAXDISCARDEDCHUNKS) {
 210         afs_osi_Wakeup((int *)afs_CacheTruncateDaemon);
 211     }
 212 }
 213
 214 /* Keep statistics on run time for afs_CacheTruncateDaemon. This is a
 215  * struct so we need only export one symbol for AIX.
 216  */
 217 static struct CTD_stats {
 218     osi_timeval_t CTD_beforeSleep;
 219     osi_timeval_t CTD_afterSleep;
 220     osi_timeval_t CTD_sleepTime;
 221     osi_timeval_t CTD_runTime;
 222     int CTD_nSleeps;
 223 } CTD_stats;
 224
 225 u_int afs_min_cache = 0;
 226 void afs_CacheTruncateDaemon(void)
 227 {
 228     osi_timeval_t CTD_tmpTime;
 229     u_int counter;
 230     u_int cb_lowat;
 231     u_int dc_hiwat = (100-CM_DCACHECOUNTFREEPCT+CM_DCACHEEXTRAPCT)*afs_cacheFiles/100;
 232     afs_min_cache = (((10 * AFS_CHUNKSIZE(0)) + afs_fsfragsize) & ~afs_fsfragsize)>>10;
 233
 234     osi_GetuTime(&CTD_stats.CTD_afterSleep);
 235     afs_TruncateDaemonRunning = 1;
 236     while (1) {
 237         cb_lowat =  ((CM_DCACHESPACEFREEPCT-CM_DCACHEEXTRAPCT)
 238                      * afs_cacheBlocks) / 100;
 239         MObtainWriteLock(&afs_xdcache,266);
 240         if (afs_CacheTooFull) {
 241           int space_needed, slots_needed;
 242             /* if we get woken up, we should try to clean something out */
 243             for (counter = 0; counter < 10; counter++) {
 244                 space_needed = afs_blocksUsed - afs_blocksDiscarded - cb_lowat;
 245                 slots_needed = dc_hiwat - afs_freeDCCount - afs_discardDCCount;
 246                 afs_GetDownD(slots_needed, &space_needed);
 247                 if ((space_needed <= 0) && (slots_needed <= 0)) {
 248                     break;
 249                 }
 250                 if (afs_termState == AFSOP_STOP_TRUNCDAEMON)
 251                     break;
 252             }
 253             if (!afs_CacheIsTooFull())
 254                 afs_CacheTooFull = 0;
 255         }
 256         MReleaseWriteLock(&afs_xdcache);
 257
 258         /*
 259          * This is a defensive check to try to avoid starving threads
 260          * that may need the global lock so thay can help free some
 261          * cache space. If this thread won't be sleeping or truncating
 262          * any cache files then give up the global lock so other
 263          * threads get a chance to run.
 264          */
 265         if ((afs_termState!=AFSOP_STOP_TRUNCDAEMON) && afs_CacheTooFull &&
 266             (!afs_blocksDiscarded || afs_WaitForCacheDrain)) {
 267             afs_osi_Wait(100, 0, 0); /* 100 milliseconds */
 268         }
 269
 270         /*
 271          * This is where we free the discarded cache elements.
 272          */
 273         while(afs_blocksDiscarded && !afs_WaitForCacheDrain &&
 274               (afs_termState!=AFSOP_STOP_TRUNCDAEMON))
 275         {
 276             afs_FreeDiscardedDCache();
 277         }
 278
 279         /* See if we need to continue to run. Someone may have
 280          * signalled us while we were executing.
 281          */
 282         if (!afs_WaitForCacheDrain && !afs_CacheTooFull &&
 283                         (afs_termState!=AFSOP_STOP_TRUNCDAEMON))
 284         {
 285             /* Collect statistics on truncate daemon. */
 286             CTD_stats.CTD_nSleeps++;
 287             osi_GetuTime(&CTD_stats.CTD_beforeSleep);
 288             afs_stats_GetDiff(CTD_tmpTime, CTD_stats.CTD_afterSleep,
 289                               CTD_stats.CTD_beforeSleep);
 290             afs_stats_AddTo(CTD_stats.CTD_runTime, CTD_tmpTime);
 291
 292             afs_TruncateDaemonRunning = 0;
 293             afs_osi_Sleep((int *)afs_CacheTruncateDaemon);
 294             afs_TruncateDaemonRunning = 1;
 295
 296             osi_GetuTime(&CTD_stats.CTD_afterSleep);
 297             afs_stats_GetDiff(CTD_tmpTime, CTD_stats.CTD_beforeSleep,
 298                               CTD_stats.CTD_afterSleep);
 299             afs_stats_AddTo(CTD_stats.CTD_sleepTime, CTD_tmpTime);
 300         }
 301         if (afs_termState == AFSOP_STOP_TRUNCDAEMON) {
 302 #ifdef AFS_AFSDB_ENV
 303             afs_termState = AFSOP_STOP_AFSDB;
 304 #else
 305             afs_termState = AFSOP_STOP_RXEVENT;
 306 #endif
 307             afs_osi_Wakeup(&afs_termState);
 308             break;
 309         }
 310     }
 311 }
 312
 313
 314 /*
 315  * afs_AdjustSize
 316  *
 317  * Description:
 318  *      Make adjustment for the new size in the disk cache entry
 319  *
 320  * Major Assumptions Here:
 321  *      Assumes that frag size is an integral power of two, less one,
 322  *      and that this is a two's complement machine.  I don't
 323  *      know of any filesystems which violate this assumption...
 324  *
 325  * Parameters:
 326  *      adc      : Ptr to dcache entry.
 327  *      anewsize : New size desired.
 328  */
 329
 330 void afs_AdjustSize(register struct dcache *adc, register afs_int32 newSize)
 331 {
 332     register afs_int32 oldSize;
 333
 334     AFS_STATCNT(afs_AdjustSize);
 335
 336     adc->dflags |= DFEntryMod;
 337     oldSize = ((adc->f.chunkBytes + afs_fsfragsize)^afs_fsfragsize)>>10;/* round up */
 338     adc->f.chunkBytes = newSize;
 339     newSize = ((newSize + afs_fsfragsize)^afs_fsfragsize)>>10;/* round up */
 340     if (newSize > oldSize) {
 341         /* We're growing the file, wakeup the daemon */
 342         afs_MaybeWakeupTruncateDaemon();
 343     }
 344     afs_blocksUsed += (newSize - oldSize);
 345     afs_stats_cmperf.cacheBlocksInUse = afs_blocksUsed; /* XXX */
 346 }
 347
 348
 349 /*
 350  * afs_GetDownD
 351  *
 352  * Description:
 353  *      This routine is responsible for moving at least one entry (but up
 354  *      to some number of them) from the LRU queue to the free queue.
 355  *
 356  * Parameters:
 357  *      anumber    : Number of entries that should ideally be moved.
 358  *      aneedSpace : How much space we need (1K blocks);
 359  *
 360  * Environment:
 361  *      The anumber parameter is just a hint; at least one entry MUST be
 362  *      moved, or we'll panic.  We must be called with afs_xdcache
 363  *      write-locked.  We should try to satisfy both anumber and aneedspace,
 364  *      whichever is more demanding - need to do several things:
 365  *      1.  only grab up to anumber victims if aneedSpace <= 0, not
 366  *          the whole set of MAXATONCE.
 367  *      2.  dynamically choose MAXATONCE to reflect severity of
 368  *          demand: something like (*aneedSpace >> (logChunk - 9))
 369  *  N.B. if we're called with aneedSpace <= 0 and anumber > 0, that
 370  *  indicates that the cache is not properly configured/tuned or
 371  *  something. We should be able to automatically correct that problem.
 372  */
 373
 374 #define MAXATONCE   16          /* max we can obtain at once */
 375 static void afs_GetDownD(int anumber, int *aneedSpace)
 376 {
 377
 378     struct dcache *tdc;
 379     struct VenusFid *afid;
 380     afs_int32 i, j, k;
 381     afs_hyper_t vtime;
 382     int skip, phase;
 383     register struct vcache *tvc;
 384     afs_uint32 victims[MAXATONCE];
 385     struct dcache *victimDCs[MAXATONCE];
 386     afs_hyper_t victimTimes[MAXATONCE];/* youngest (largest LRU time) first */
 387     afs_uint32 victimPtr;           /* next free item in victim arrays */
 388     afs_hyper_t maxVictimTime;      /* youngest (largest LRU time) victim */
 389     afs_uint32 maxVictimPtr;                /* where it is */
 390     int discard;
 391
 392     AFS_STATCNT(afs_GetDownD);
 393     if (CheckLock(&afs_xdcache) != -1)
 394         osi_Panic("getdownd nolock");
 395     /* decrement anumber first for all dudes in free list */
 396     /* SHOULD always decrement anumber first, even if aneedSpace >0,
 397      * because we should try to free space even if anumber <=0 */
 398     if (!aneedSpace || *aneedSpace <= 0) {
 399         anumber -= afs_freeDCCount;
 400         if (anumber <= 0) return;       /* enough already free */
 401     }
 402     /* bounds check parameter */
 403     if (anumber > MAXATONCE)
 404         anumber = MAXATONCE;   /* all we can do */
 405
 406     /*
 407      * The phase variable manages reclaims.  Set to 0, the first pass,
 408      * we don't reclaim active entries.  Set to 1, we reclaim even active
 409      * ones.
 410      */
 411     phase = 0;
 412     for (i = 0; i < afs_cacheFiles; i++)
 413         /* turn off all flags */
 414         afs_indexFlags[i] &= ~IFFlag;
 415
 416     while (anumber > 0 || (aneedSpace && *aneedSpace >0)) {
 417         /* find oldest entries for reclamation */
 418         maxVictimPtr = victimPtr = 0;
 419         hzero(maxVictimTime);
 420         /* select victims from access time array */
 421         for (i = 0; i < afs_cacheFiles; i++) {
 422             if (afs_indexFlags[i] & (IFDataMod | IFFree | IFDiscarded)) {
 423               /* skip if dirty or already free */
 424               continue;
 425             }
 426             tdc = afs_indexTable[i];
 427             if (tdc && (tdc->refCount != 0)) {
 428               /* Referenced; can't use it! */
 429               continue;
 430             }
 431             hset(vtime, afs_indexTimes[i]);
 432
 433             /* if we've already looked at this one, skip it */
 434             if (afs_indexFlags[i] & IFFlag) continue;
 435
 436             if (victimPtr < MAXATONCE) {
 437                 /* if there's at least one free victim slot left */
 438                 victims[victimPtr] = i;
 439                 hset(victimTimes[victimPtr], vtime);
 440                 if (hcmp(vtime, maxVictimTime) > 0) {
 441                     hset(maxVictimTime, vtime);
 442                     maxVictimPtr = victimPtr;
 443                 }
 444                 victimPtr++;
 445             }
 446             else if (hcmp(vtime, maxVictimTime) < 0) {
 447                 /*
 448                  * We're older than youngest victim, so we replace at
 449                  * least one victim
 450                  */
 451                 /* find youngest (largest LRU) victim */
 452                 j = maxVictimPtr;
 453                 if (j == victimPtr) osi_Panic("getdownd local");
 454                 victims[j] = i;
 455                 hset(victimTimes[j], vtime);
 456                 /* recompute maxVictimTime */
 457                 hset(maxVictimTime, vtime);
 458                 for(j = 0; j < victimPtr; j++)
 459                     if (hcmp(maxVictimTime, victimTimes[j]) < 0) {
 460                         hset(maxVictimTime, victimTimes[j]);
 461                         maxVictimPtr = j;
 462                     }
 463             }
 464         } /* big for loop */
 465
 466         /* now really reclaim the victims */
 467         j = 0;  /* flag to track if we actually got any of the victims */
 468         /* first, hold all the victims, since we're going to release the lock
 469          * during the truncate operation.
 470          */
 471         for(i=0; i < victimPtr; i++) {
 472             tdc = afs_GetDSlot(victims[i], 0);
 473             /* We got tdc->tlock(R) here */
 474             if (tdc->refCount == 1)
 475                 victimDCs[i] = tdc;
 476             else
 477                 victimDCs[i] = 0;
 478             ReleaseReadLock(&tdc->tlock);
 479             if (!victimDCs[i]) afs_PutDCache(tdc);
 480         }
 481         for(i = 0; i < victimPtr; i++) {
 482             /* q is first elt in dcache entry */
 483             tdc = victimDCs[i];
 484             /* now, since we're dropping the afs_xdcache lock below, we
 485              * have to verify, before proceeding, that there are no other
 486              * references to this dcache entry, even now.  Note that we
 487              * compare with 1, since we bumped it above when we called
 488              * afs_GetDSlot to preserve the entry's identity.
 489              */
 490             if (tdc && tdc->refCount == 1) {
 491                 unsigned char chunkFlags;
 492                 afs_size_t tchunkoffset;
 493                 afid = &tdc->f.fid;
 494                 /* xdcache is lower than the xvcache lock */
 495                 MReleaseWriteLock(&afs_xdcache);
 496                 MObtainReadLock(&afs_xvcache);
 497                 tvc = afs_FindVCache(afid, 0, 0 /* no stats, no vlru */ );
 498                 MReleaseReadLock(&afs_xvcache);
 499                 MObtainWriteLock(&afs_xdcache, 527);
 500                 skip = 0;
 501                 if (tdc->refCount > 1) skip = 1;
 502                 if (tvc) {
 503                     tchunkoffset = AFS_CHUNKTOBASE(tdc->f.chunk);
 504                     chunkFlags = afs_indexFlags[tdc->index];
 505                     if (phase == 0 && osi_Active(tvc)) skip = 1;
 506                     if (phase > 0 && osi_Active(tvc) && (tvc->states & CDCLock)
 507                                 && (chunkFlags & IFAnyPages)) skip = 1;
 508                     if (chunkFlags & IFDataMod) skip = 1;
 509                     afs_Trace4(afs_iclSetp, CM_TRACE_GETDOWND,
 510                                ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32, skip,
 511                                ICL_TYPE_INT32, tdc->index,
 512                                ICL_TYPE_OFFSET,
 513                                ICL_HANDLE_OFFSET(tchunkoffset));
 514
 515 #if     defined(AFS_SUN5_ENV)
 516                     /*
 517                      * Now we try to invalidate pages.  We do this only for
 518                      * Solaris.  For other platforms, it's OK to recycle a
 519                      * dcache entry out from under a page, because the strategy
 520                      * function can call afs_GetDCache().
 521                      */
 522                     if (!skip && (chunkFlags & IFAnyPages)) {
 523                         int code;
 524
 525                         MReleaseWriteLock(&afs_xdcache);
 526                         MObtainWriteLock(&tvc->vlock, 543);
 527                         if (tvc->multiPage) {
 528                             skip = 1;
 529                             goto endmultipage;
 530                         }
 531                         /* block locking pages */
 532                         tvc->vstates |= VPageCleaning;
 533                         /* block getting new pages */
 534                         tvc->activeV++;
 535                         MReleaseWriteLock(&tvc->vlock);
 536                         /* One last recheck */
 537                         MObtainWriteLock(&afs_xdcache, 333);
 538                         chunkFlags = afs_indexFlags[tdc->index];
 539                         if (tdc->refCount > 1
 540                             || (chunkFlags & IFDataMod)
 541                             || (osi_Active(tvc) && (tvc->states & CDCLock)
 542                                 && (chunkFlags & IFAnyPages))) {
 543                             skip = 1;
 544                             MReleaseWriteLock(&afs_xdcache);
 545                             goto endputpage;
 546                         }
 547                         MReleaseWriteLock(&afs_xdcache);
 548
 549                         code = osi_VM_GetDownD(tvc, tdc);
 550
 551                         MObtainWriteLock(&afs_xdcache,269);
 552                         /* we actually removed all pages, clean and dirty */
 553                         if (code == 0) {
 554                             afs_indexFlags[tdc->index] &= ~(IFDirtyPages| IFAnyPages);
 555                         } else
 556                             skip = 1;
 557                         MReleaseWriteLock(&afs_xdcache);
 558 endputpage:
 559                         MObtainWriteLock(&tvc->vlock, 544);
 560                         if (--tvc->activeV == 0 && (tvc->vstates & VRevokeWait)) {
 561                             tvc->vstates &= ~VRevokeWait;
 562                             afs_osi_Wakeup((char *)&tvc->vstates);
 563
 564                         }
 565                         if (tvc->vstates & VPageCleaning) {
 566                             tvc->vstates &= ~VPageCleaning;
 567                             afs_osi_Wakeup((char *)&tvc->vstates);
 568                         }
 569 endmultipage:
 570                         MReleaseWriteLock(&tvc->vlock);
 571                     } else
 572 #endif  /* AFS_SUN5_ENV */
 573                     {
 574                         MReleaseWriteLock(&afs_xdcache);
 575                     }
 576
 577                     AFS_FAST_RELE(tvc);
 578                     MObtainWriteLock(&afs_xdcache, 528);
 579                     if (afs_indexFlags[tdc->index] &
 580                          (IFDataMod | IFDirtyPages | IFAnyPages)) skip = 1;
 581                     if (tdc->refCount > 1) skip = 1;
 582                 }
 583 #if     defined(AFS_SUN5_ENV)
 584                 else {
 585                     /* no vnode, so IFDirtyPages is spurious (we don't
 586                      * sweep dcaches on vnode recycling, so we can have
 587                      * DIRTYPAGES set even when all pages are gone).  Just
 588                      * clear the flag.
 589                      * Hold vcache lock to prevent vnode from being
 590                      * created while we're clearing IFDirtyPages.
 591                      */
 592                     afs_indexFlags[tdc->index] &= ~(IFDirtyPages | IFAnyPages);
 593                 }
 594 #endif
 595                 if (skip) {
 596                     /* skip this guy and mark him as recently used */
 597                     afs_indexFlags[tdc->index] |= IFFlag;
 598                     afs_Trace4(afs_iclSetp, CM_TRACE_GETDOWND,
 599                                ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32, 2,
 600                                ICL_TYPE_INT32, tdc->index,
 601                                ICL_TYPE_OFFSET,
 602                                ICL_HANDLE_OFFSET(tchunkoffset));
 603                 }
 604                 else {
 605                     /* flush this dude from the data cache and reclaim;
 606                      * first, make sure no one will care that we damage
 607                      * it, by removing it from all hash tables.  Then,
 608                      * melt it down for parts.  Note that any concurrent
 609                      * (new possibility!) calls to GetDownD won't touch
 610                      * this guy because his reference count is > 0. */
 611                     afs_Trace4(afs_iclSetp, CM_TRACE_GETDOWND,
 612                                ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32, 3,
 613                                ICL_TYPE_INT32, tdc->index,
 614                                ICL_TYPE_OFFSET,
 615                                ICL_HANDLE_OFFSET(tchunkoffset));
 616 #ifndef AFS_DEC_ENV
 617                     AFS_STATCNT(afs_gget);
 618 #endif
 619                     afs_HashOutDCache(tdc);
 620                     if (tdc->f.chunkBytes != 0) {
 621                         discard = 1;
 622                         if (aneedSpace)
 623                           *aneedSpace -= (tdc->f.chunkBytes + afs_fsfragsize) >> 10;
 624                     } else {
 625                         discard = 0;
 626                     }
 627                     if (discard) {
 628                         afs_DiscardDCache(tdc);
 629                     } else {
 630                         afs_FreeDCache(tdc);
 631                     }
 632                     anumber--;
 633                     j = 1;      /* we reclaimed at least one victim */
 634                 }
 635             }
 636             afs_PutDCache(tdc);
 637         }
 638
 639         if (phase == 0) {
 640             /* Phase is 0 and no one was found, so try phase 1 (ignore
 641              * osi_Active flag) */
 642             if (j == 0) {
 643                 phase = 1;
 644                 for (i = 0; i < afs_cacheFiles; i++)
 645                     /* turn off all flags */
 646                     afs_indexFlags[i] &= ~IFFlag;
 647             }
 648         }
 649         else {
 650             /* found no one in phase 1, we're hosed */
 651             if (victimPtr == 0) break;
 652         }
 653     } /* big while loop */
 654     return;
 655
 656 } /*afs_GetDownD*/
 657
 658
 659 /*
 660  * Description: remove adc from any hash tables that would allow it to be located
 661  * again by afs_FindDCache or afs_GetDCache.
 662  *
 663  * Parameters: adc -- pointer to dcache entry to remove from hash tables.
 664  *
 665  * Locks: Must have the afs_xdcache lock write-locked to call this function.
 666  */
 667 int afs_HashOutDCache(struct dcache *adc)
 668 {
 669     int i, us;
 670
 671 #ifndef AFS_DEC_ENV
 672     AFS_STATCNT(afs_glink);
 673 #endif
 674     /* we know this guy's in the LRUQ.  We'll move dude into DCQ below */
 675     DZap(&adc->f.inode);
 676     /* if this guy is in the hash table, pull him out */
 677     if (adc->f.fid.Fid.Volume != 0) {
 678         /* remove entry from first hash chains */
 679         i = DCHash(&adc->f.fid, adc->f.chunk);
 680         us = afs_dchashTbl[i];
 681         if (us == adc->index) {
 682             /* first dude in the list */
 683             afs_dchashTbl[i] = afs_dcnextTbl[adc->index];
 684         }
 685         else {
 686             /* somewhere on the chain */
 687             while (us != NULLIDX) {
 688                 if (afs_dcnextTbl[us] == adc->index) {
 689                     /* found item pointing at the one to delete */
 690                     afs_dcnextTbl[us] = afs_dcnextTbl[adc->index];
 691                     break;
 692                 }
 693                 us = afs_dcnextTbl[us];
 694             }
 695             if (us == NULLIDX) osi_Panic("dcache hc");
 696         }
 697         /* remove entry from *other* hash chain */
 698         i = DVHash(&adc->f.fid);
 699         us = afs_dvhashTbl[i];
 700         if (us == adc->index) {
 701             /* first dude in the list */
 702             afs_dvhashTbl[i] = afs_dvnextTbl[adc->index];
 703         }
 704         else {
 705             /* somewhere on the chain */
 706             while (us != NULLIDX) {
 707                 if (afs_dvnextTbl[us] == adc->index) {
 708                     /* found item pointing at the one to delete */
 709                     afs_dvnextTbl[us] = afs_dvnextTbl[adc->index];
 710                     break;
 711                 }
 712                 us = afs_dvnextTbl[us];
 713             }
 714             if (us == NULLIDX) osi_Panic("dcache hv");
 715         }
 716     }
 717
 718     /* prevent entry from being found on a reboot (it is already out of
 719      * the hash table, but after a crash, we just look at fid fields of
 720      * stable (old) entries).
 721      */
 722     adc->f.fid.Fid.Volume = 0;  /* invalid */
 723
 724     /* mark entry as modified */
 725     adc->dflags |= DFEntryMod;
 726
 727     /* all done */
 728     return 0;
 729 } /*afs_HashOutDCache */
 730
 731
 732 /*
 733  * afs_FlushDCache
 734  *
 735  * Description:
 736  *      Flush the given dcache entry, pulling it from hash chains
 737  *      and truncating the associated cache file.
 738  *
 739  * Arguments:
 740  *      adc: Ptr to dcache entry to flush.
 741  *
 742  * Environment:
 743  *      This routine must be called with the afs_xdcache lock held
 744  *      (in write mode)
 745  */
 746
 747 void afs_FlushDCache(register struct dcache *adc)
 748 {
 749     AFS_STATCNT(afs_FlushDCache);
 750     /*
 751      * Bump the number of cache files flushed.
 752      */
 753     afs_stats_cmperf.cacheFlushes++;
 754
 755     /* remove from all hash tables */
 756     afs_HashOutDCache(adc);
 757
 758     /* Free its space; special case null operation, since truncate operation
 759      * in UFS is slow even in this case, and this allows us to pre-truncate
 760      * these files at more convenient times with fewer locks set
 761      * (see afs_GetDownD).
 762      */
 763     if (adc->f.chunkBytes != 0) {
 764         afs_DiscardDCache(adc);
 765         afs_MaybeWakeupTruncateDaemon();
 766     } else {
 767         afs_FreeDCache(adc);
 768     }
 769
 770     if (afs_WaitForCacheDrain) {
 771         if (afs_blocksUsed <=
 772             (CM_CACHESIZEDRAINEDPCT*afs_cacheBlocks)/100) {
 773             afs_WaitForCacheDrain = 0;
 774             afs_osi_Wakeup(&afs_WaitForCacheDrain);
 775         }
 776     }
 777 } /*afs_FlushDCache*/
 778
 779
 780 /*
 781  * afs_FreeDCache
 782  *
 783  * Description: put a dcache entry on the free dcache entry list.
 784  *
 785  * Parameters: adc -- dcache entry to free
 786  *
 787  * Environment: called with afs_xdcache lock write-locked.
 788  */
 789 static void afs_FreeDCache(register struct dcache *adc)
 790 {
 791     /* Thread on free list, update free list count and mark entry as
 792      * freed in its indexFlags element.  Also, ensure DCache entry gets
 793      * written out (set DFEntryMod).
 794      */
 795
 796     afs_dvnextTbl[adc->index] = afs_freeDCList;
 797     afs_freeDCList = adc->index;
 798     afs_freeDCCount++;
 799     afs_indexFlags[adc->index] |= IFFree;
 800     adc->dflags |= DFEntryMod;
 801
 802     if (afs_WaitForCacheDrain) {
 803         if ((afs_blocksUsed - afs_blocksDiscarded) <=
 804             (CM_CACHESIZEDRAINEDPCT*afs_cacheBlocks)/100) {
 805             afs_WaitForCacheDrain = 0;
 806             afs_osi_Wakeup(&afs_WaitForCacheDrain);
 807         }
 808     }
 809 }
 810
 811 /*
 812  * afs_DiscardDCache
 813  *
 814  * Description:
 815  *      Discard the cache element by moving it to the discardDCList.
 816  *      This puts the cache element into a quasi-freed state, where
 817  *      the space may be reused, but the file has not been truncated.
 818  *
 819  * Major Assumptions Here:
 820  *      Assumes that frag size is an integral power of two, less one,
 821  *      and that this is a two's complement machine.  I don't
 822  *      know of any filesystems which violate this assumption...
 823  *
 824  * Parameters:
 825  *      adc      : Ptr to dcache entry.
 826  *
 827  * Environment:
 828  *      Must be called with afs_xdcache write-locked.
 829  */
 830
 831 static void afs_DiscardDCache(register struct dcache *adc)
 832 {
 833     register afs_int32 size;
 834
 835     AFS_STATCNT(afs_DiscardDCache);
 836
 837     osi_Assert(adc->refCount == 1);
 838
 839     size = ((adc->f.chunkBytes + afs_fsfragsize)^afs_fsfragsize)>>10;/* round up */
 840     afs_blocksDiscarded += size;
 841     afs_stats_cmperf.cacheBlocksDiscarded = afs_blocksDiscarded;
 842
 843     afs_dvnextTbl[adc->index] = afs_discardDCList;
 844     afs_discardDCList = adc->index;
 845     afs_discardDCCount++;
 846
 847     adc->f.fid.Fid.Volume = 0;
 848     adc->dflags |= DFEntryMod;
 849     afs_indexFlags[adc->index] |= IFDiscarded;
 850
 851     if (afs_WaitForCacheDrain) {
 852         if ((afs_blocksUsed - afs_blocksDiscarded) <=
 853             (CM_CACHESIZEDRAINEDPCT*afs_cacheBlocks)/100) {
 854             afs_WaitForCacheDrain = 0;
 855             afs_osi_Wakeup(&afs_WaitForCacheDrain);
 856         }
 857     }
 858
 859 } /*afs_DiscardDCache*/
 860
 861 /*
 862  * afs_FreeDiscardedDCache
 863  *
 864  * Description:
 865  *     Free the next element on the list of discarded cache elements.
 866  */
 867 static void afs_FreeDiscardedDCache(void)
 868 {
 869     register struct dcache *tdc;
 870     register struct osi_file *tfile;
 871     register afs_int32 size;
 872
 873     AFS_STATCNT(afs_FreeDiscardedDCache);
 874
 875     MObtainWriteLock(&afs_xdcache,510);
 876     if (!afs_blocksDiscarded) {
 877         MReleaseWriteLock(&afs_xdcache);
 878         return;
 879     }
 880
 881     /*
 882      * Get an entry from the list of discarded cache elements
 883      */
 884     tdc = afs_GetDSlot(afs_discardDCList, 0);
 885     osi_Assert(tdc->refCount == 1);
 886     ReleaseReadLock(&tdc->tlock);
 887
 888     afs_discardDCList = afs_dvnextTbl[tdc->index];
 889     afs_dvnextTbl[tdc->index] = NULLIDX;
 890     afs_discardDCCount--;
 891     size = ((tdc->f.chunkBytes + afs_fsfragsize)^afs_fsfragsize)>>10;/* round up */
 892     afs_blocksDiscarded -= size;
 893     afs_stats_cmperf.cacheBlocksDiscarded = afs_blocksDiscarded;
 894     /* We can lock because we just took it off the free list */
 895     ObtainWriteLock(&tdc->lock, 626);
 896     MReleaseWriteLock(&afs_xdcache);
 897
 898     /*
 899      * Truncate the element to reclaim its space
 900      */
 901     tfile = afs_CFileOpen(tdc->f.inode);
 902     afs_CFileTruncate(tfile, 0);
 903     afs_CFileClose(tfile);
 904     afs_AdjustSize(tdc, 0);
 905
 906     /*
 907      * Free the element we just truncated
 908      */
 909     MObtainWriteLock(&afs_xdcache,511);
 910     afs_indexFlags[tdc->index] &= ~IFDiscarded;
 911     afs_FreeDCache(tdc);
 912     ReleaseWriteLock(&tdc->lock);
 913     afs_PutDCache(tdc);
 914     MReleaseWriteLock(&afs_xdcache);
 915 }
 916
 917 /*
 918  * afs_MaybeFreeDiscardedDCache
 919  *
 920  * Description:
 921  *      Free as many entries from the list of discarded cache elements
 922  *      as we need to get the free space down below CM_WAITFORDRAINPCT (98%).
 923  *
 924  * Parameters:
 925  *      None
 926  */
 927 int afs_MaybeFreeDiscardedDCache(void)
 928 {
 929
 930     AFS_STATCNT(afs_MaybeFreeDiscardedDCache);
 931
 932     while (afs_blocksDiscarded &&
 933            (afs_blocksUsed > (CM_WAITFORDRAINPCT*afs_cacheBlocks)/100)) {
 934         afs_FreeDiscardedDCache();
 935     }
 936     return 0;
 937 }
 938
 939 /*
 940  * afs_GetDownDSlot
 941  *
 942  * Description:
 943  *      Try to free up a certain number of disk slots.
 944  *
 945  * Parameters:
 946  *      anumber : Targeted number of disk slots to free up.
 947  *
 948  * Environment:
 949  *      Must be called with afs_xdcache write-locked.
 950  */
 951 static void afs_GetDownDSlot(int anumber)
 952 {
 953     struct afs_q *tq, *nq;
 954     struct dcache *tdc;
 955     int ix;
 956     unsigned int i=0;
 957     unsigned int cnt;
 958
 959     AFS_STATCNT(afs_GetDownDSlot);
 960     if (cacheDiskType == AFS_FCACHE_TYPE_MEM)
 961         osi_Panic("diskless getdowndslot");
 962
 963     if (CheckLock(&afs_xdcache) != -1)
 964         osi_Panic("getdowndslot nolock");
 965
 966     /* decrement anumber first for all dudes in free list */
 967     for(tdc = afs_freeDSList; tdc; tdc = (struct dcache *)tdc->lruq.next)
 968         anumber--;
 969     if (anumber <= 0)
 970         return;                         /* enough already free */
 971
 972     for(cnt=0, tq = afs_DLRU.prev; tq != &afs_DLRU && anumber > 0;
 973         tq = nq, cnt++) {
 974         tdc = (struct dcache *) tq;     /* q is first elt in dcache entry */
 975         nq = QPrev(tq); /* in case we remove it */
 976         if (tdc->refCount == 0) {
 977             if ((ix=tdc->index) == NULLIDX) osi_Panic("getdowndslot");
 978             /* pull the entry out of the lruq and put it on the free list */
 979             QRemove(&tdc->lruq);
 980
 981             /* write-through if modified */
 982             if (tdc->dflags & DFEntryMod) {
 983 #if defined(AFS_SGI_ENV) && defined(AFS_SGI_SHORTSTACK)
 984                 /*
 985                  * ask proxy to do this for us - we don't have the stack space
 986                  */
 987                 while (tdc->dflags & DFEntryMod) {
 988                     int s;
 989                     AFS_GUNLOCK();
 990                     s = SPLOCK(afs_sgibklock);
 991                     if (afs_sgibklist == NULL) {
 992                         /* if slot is free, grab it. */
 993                         afs_sgibklist = tdc;
 994                         SV_SIGNAL(&afs_sgibksync);
 995                     }
 996                     /* wait for daemon to (start, then) finish. */
 997                     SP_WAIT(afs_sgibklock, s, &afs_sgibkwait, PINOD);
 998                     AFS_GLOCK();
 999                 }
1000 #else
1001                 tdc->dflags &= ~DFEntryMod;
1002                 afs_WriteDCache(tdc, 1);
1003 #endif
1004             }
1005
1006             tdc->stamp = 0;
1007 #ifdef IHINT
1008              if (tdc->ihint) {
1009                  struct osi_file * f = (struct osi_file *)tdc->ihint;
1010                  tdc->ihint = 0;
1011                  afs_UFSClose(f);
1012                  nihints--;
1013              }
1014 #endif /* IHINT */
1015
1016
1017             /* finally put the entry in the free list */
1018             afs_indexTable[ix] = NULL;
1019             afs_indexFlags[ix] &= ~IFEverUsed;
1020             tdc->index = NULLIDX;
1021             tdc->lruq.next = (struct afs_q *) afs_freeDSList;
1022             afs_freeDSList = tdc;
1023             anumber--;
1024         }
1025     }
1026 } /*afs_GetDownDSlot*/
1027
1028
1029 /*
1030  * afs_RefDCache
1031  *
1032  * Description:
1033  *      Increment the reference count on a disk cache entry,
1034  *      which already has a non-zero refcount.  In order to
1035  *      increment the refcount of a zero-reference entry, you
1036  *      have to hold afs_xdcache.
1037  *
1038  * Parameters:
1039  *      adc : Pointer to the dcache entry to increment.
1040  *
1041  * Environment:
1042  *      Nothing interesting.
1043  */
1044 int afs_RefDCache(struct dcache *adc)
1045 {
1046     ObtainWriteLock(&adc->tlock, 627);
1047     if (adc->refCount < 0)
1048         osi_Panic("RefDCache: negative refcount");
1049     adc->refCount++;
1050     ReleaseWriteLock(&adc->tlock);
1051     return 0;
1052 }
1053
1054
1055 /*
1056  * afs_PutDCache
1057  *
1058  * Description:
1059  *      Decrement the reference count on a disk cache entry.
1060  *
1061  * Parameters:
1062  *      ad : Ptr to the dcache entry to decrement.
1063  *
1064  * Environment:
1065  *      Nothing interesting.
1066  */
1067 int afs_PutDCache(register struct dcache *adc)
1068 {
1069     AFS_STATCNT(afs_PutDCache);
1070     ObtainWriteLock(&adc->tlock, 276);
1071     if (adc->refCount <= 0)
1072         osi_Panic("putdcache");
1073     --adc->refCount;
1074     ReleaseWriteLock(&adc->tlock);
1075     return 0;
1076 }
1077
1078
1079 /*
1080  * afs_TryToSmush
1081  *
1082  * Description:
1083  *      Try to discard all data associated with this file from the
1084  *      cache.
1085  *
1086  * Parameters:
1087  *      avc : Pointer to the cache info for the file.
1088  *
1089  * Environment:
1090  *      Both pvnLock and lock are write held.
1091  */
1092 void afs_TryToSmush(register struct vcache *avc, struct AFS_UCRED *acred,
1093         int sync)
1094 {
1095     register struct dcache *tdc;
1096     register int index;
1097     register int i;
1098     AFS_STATCNT(afs_TryToSmush);
1099     afs_Trace2(afs_iclSetp, CM_TRACE_TRYTOSMUSH, ICL_TYPE_POINTER, avc,
1100                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->m.Length));
1101     sync = 1;                           /* XX Temp testing XX*/
1102
1103 #if     defined(AFS_SUN5_ENV)
1104     ObtainWriteLock(&avc->vlock, 573);
1105     avc->activeV++;     /* block new getpages */
1106     ReleaseWriteLock(&avc->vlock);
1107 #endif
1108
1109     /* Flush VM pages */
1110     osi_VM_TryToSmush(avc, acred, sync);
1111
1112     /*
1113      * Get the hash chain containing all dce's for this fid
1114      */
1115     i = DVHash(&avc->fid);
1116     MObtainWriteLock(&afs_xdcache,277);
1117     for(index = afs_dvhashTbl[i]; index != NULLIDX; index=i) {
1118       i = afs_dvnextTbl[index]; /* next pointer this hash table */
1119       if (afs_indexUnique[index] == avc->fid.Fid.Unique) {
1120         int releaseTlock = 1;
1121         tdc = afs_GetDSlot(index, NULL);
1122         if (!FidCmp(&tdc->f.fid, &avc->fid)) {
1123             if (sync) {
1124                 if ((afs_indexFlags[index] & IFDataMod) == 0 &&
1125                     tdc->refCount == 1) {
1126                     ReleaseReadLock(&tdc->tlock);
1127                     releaseTlock = 0;
1128                     afs_FlushDCache(tdc);
1129                 }
1130             } else
1131                 afs_indexTable[index] = 0;
1132         }
1133         if (releaseTlock) ReleaseReadLock(&tdc->tlock);
1134         afs_PutDCache(tdc);
1135       }
1136     }
1137 #if     defined(AFS_SUN5_ENV)
1138     ObtainWriteLock(&avc->vlock, 545);
1139     if (--avc->activeV == 0 && (avc->vstates & VRevokeWait)) {
1140         avc->vstates &= ~VRevokeWait;
1141         afs_osi_Wakeup((char *)&avc->vstates);
1142     }
1143     ReleaseWriteLock(&avc->vlock);
1144 #endif
1145     MReleaseWriteLock(&afs_xdcache);
1146     /*
1147      * It's treated like a callback so that when we do lookups we'll invalidate the unique bit if any
1148      * trytoSmush occured during the lookup call
1149      */
1150     afs_allCBs++;
1151 }
1152
1153 /*
1154  * afs_FindDCache
1155  *
1156  * Description:
1157  *      Given the cached info for a file and a byte offset into the
1158  *      file, make sure the dcache entry for that file and containing
1159  *      the given byte is available, returning it to our caller.
1160  *
1161  * Parameters:
1162  *      avc   : Pointer to the (held) vcache entry to look in.
1163  *      abyte : Which byte we want to get to.
1164  *
1165  * Returns:
1166  *      Pointer to the dcache entry covering the file & desired byte,
1167  *      or NULL if not found.
1168  *
1169  * Environment:
1170  *      The vcache entry is held upon entry.
1171  */
1172
1173 struct dcache *afs_FindDCache(register struct vcache *avc, afs_size_t abyte)
1174 {
1175     afs_int32 chunk;
1176     register afs_int32 i, index;
1177     register struct dcache *tdc;
1178
1179     AFS_STATCNT(afs_FindDCache);
1180     chunk = AFS_CHUNK(abyte);
1181
1182     /*
1183      * Hash on the [fid, chunk] and get the corresponding dcache index
1184      * after write-locking the dcache.
1185      */
1186     i = DCHash(&avc->fid, chunk);
1187     MObtainWriteLock(&afs_xdcache,278);
1188     for(index = afs_dchashTbl[i]; index != NULLIDX;) {
1189       if (afs_indexUnique[index] == avc->fid.Fid.Unique) {
1190         tdc = afs_GetDSlot(index, NULL);
1191         ReleaseReadLock(&tdc->tlock);
1192         if (!FidCmp(&tdc->f.fid, &avc->fid) && chunk == tdc->f.chunk) {
1193             break;  /* leaving refCount high for caller */
1194         }
1195         afs_PutDCache(tdc);
1196       }
1197       index = afs_dcnextTbl[index];
1198     }
1199     MReleaseWriteLock(&afs_xdcache);
1200     if (index != NULLIDX) {
1201         hset(afs_indexTimes[tdc->index], afs_indexCounter);
1202         hadd32(afs_indexCounter, 1);
1203         return tdc;
1204     }
1205     else
1206         return NULL;
1207
1208 } /*afs_FindDCache*/
1209
1210
1211 /*
1212  * afs_UFSCacheStoreProc
1213  *
1214  * Description:
1215  *      Called upon store.
1216  *
1217  * Parameters:
1218  *      acall : Ptr to the Rx call structure involved.
1219  *      afile : Ptr to the related file descriptor.
1220  *      alen  : Size of the file in bytes.
1221  *      avc   : Ptr to the vcache entry.
1222  *      shouldWake : is it "safe" to return early from close() ?
1223  *      abytesToXferP  : Set to the number of bytes to xfer.
1224  *                       NOTE: This parameter is only used if AFS_NOSTATS
1225  *                              is not defined.
1226  *      abytesXferredP : Set to the number of bytes actually xferred.
1227  *                       NOTE: This parameter is only used if AFS_NOSTATS
1228  *                              is not defined.
1229  *
1230  * Environment:
1231  *      Nothing interesting.
1232  */
1233 static int afs_UFSCacheStoreProc(register struct rx_call *acall,
1234         struct osi_file *afile, register afs_int32 alen, struct vcache *avc,
1235         int *shouldWake, afs_size_t *abytesToXferP, afs_size_t *abytesXferredP)
1236 {
1237     afs_int32 code, got;
1238     register char *tbuffer;
1239     register int tlen;
1240
1241     AFS_STATCNT(UFS_CacheStoreProc);
1242
1243 #ifndef AFS_NOSTATS
1244     /*
1245      * In this case, alen is *always* the amount of data we'll be trying
1246      * to ship here.
1247      */
1248     (*abytesToXferP)  = alen;
1249     (*abytesXferredP) = 0;
1250 #endif /* AFS_NOSTATS */
1251
1252     afs_Trace4(afs_iclSetp, CM_TRACE_STOREPROC, ICL_TYPE_POINTER, avc,
1253                         ICL_TYPE_FID, &(avc->fid),
1254                         ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->m.Length),
1255                         ICL_TYPE_INT32, alen);
1256     tbuffer = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
1257     while (alen > 0) {
1258         tlen = (alen > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : alen);
1259         got = afs_osi_Read(afile, -1, tbuffer, tlen);
1260         if ((got < 0)
1261 #if     !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
1262             || (got != tlen && getuerror())
1263 #endif
1264             ) {
1265             osi_FreeLargeSpace(tbuffer);
1266             return EIO;
1267         }
1268         afs_Trace1(afs_iclSetp, CM_TRACE_STOREPROC2, ICL_TYPE_INT32, got);
1269         RX_AFS_GUNLOCK();
1270         code = rx_Write(acall, tbuffer, got);  /* writing 0 bytes will
1271         * push a short packet.  Is that really what we want, just because the
1272         * data didn't come back from the disk yet?  Let's try it and see. */
1273         RX_AFS_GLOCK();
1274 #ifndef AFS_NOSTATS
1275         (*abytesXferredP) += code;
1276 #endif /* AFS_NOSTATS */
1277         if (code != got) {
1278             osi_FreeLargeSpace(tbuffer);
1279             return -33;
1280         }
1281         alen -= got;
1282         /*
1283          * If file has been locked on server, we can allow the store
1284          * to continue.
1285          */
1286         if (shouldWake && *shouldWake && (rx_GetRemoteStatus(acall) & 1)) {
1287             *shouldWake = 0;  /* only do this once */
1288             afs_wakeup(avc);
1289         }
1290     }
1291     afs_Trace4(afs_iclSetp, CM_TRACE_STOREPROC, ICL_TYPE_POINTER, avc,
1292                         ICL_TYPE_FID, &(avc->fid),
1293                         ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->m.Length),
1294                         ICL_TYPE_INT32, alen);
1295     osi_FreeLargeSpace(tbuffer);
1296     return 0;
1297
1298 } /* afs_UFSCacheStoreProc*/
1299
1300
1301 /*
1302  * afs_UFSCacheFetchProc
1303  *
1304  * Description:
1305  *      Routine called on fetch; also tells people waiting for data
1306  *      that more has arrived.
1307  *
1308  * Parameters:
1309  *      acall : Ptr to the Rx call structure.
1310  *      afile : File descriptor for the cache file.
1311  *      abase : Base offset to fetch.
1312  *      adc   : Ptr to the dcache entry for the file, write-locked.
1313  *      avc   : Ptr to the vcache entry for the file.
1314  *      abytesToXferP  : Set to the number of bytes to xfer.
1315  *                       NOTE: This parameter is only used if AFS_NOSTATS
1316  *                              is not defined.
1317  *      abytesXferredP : Set to the number of bytes actually xferred.
1318  *                       NOTE: This parameter is only used if AFS_NOSTATS
1319  *                              is not defined.
1320  *
1321  * Environment:
1322  *      Nothing interesting.
1323  */
1324
1325 static int afs_UFSCacheFetchProc(register struct rx_call *acall,
1326         struct osi_file *afile, afs_size_t abase, struct dcache *adc,
1327         struct vcache *avc, afs_size_t *abytesToXferP,
1328         afs_size_t *abytesXferredP, afs_int32 lengthFound)
1329 {
1330     afs_int32 length;
1331     register afs_int32 code;
1332     register char *tbuffer;
1333     register int tlen;
1334     int moredata = 0;
1335
1336     AFS_STATCNT(UFS_CacheFetchProc);
1337     osi_Assert(WriteLocked(&adc->lock));
1338     afile->offset = 0;  /* Each time start from the beginning */
1339     length = lengthFound;
1340 #ifndef AFS_NOSTATS
1341     (*abytesToXferP)  = 0;
1342     (*abytesXferredP) = 0;
1343 #endif /* AFS_NOSTATS */
1344     tbuffer = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
1345     adc->validPos = abase;
1346     do {
1347         if (moredata) {
1348             RX_AFS_GUNLOCK();
1349             code = rx_Read(acall, (char *)&length, sizeof(afs_int32));
1350             RX_AFS_GLOCK();
1351             length = ntohl(length);
1352             if (code != sizeof(afs_int32)) {
1353                 osi_FreeLargeSpace(tbuffer);
1354                 code = rx_Error(acall);
1355                 return (code?code:-1);      /* try to return code, not -1 */
1356             }
1357         }
1358         /*
1359          * The fetch protocol is extended for the AFS/DFS translator
1360          * to allow multiple blocks of data, each with its own length,
1361          * to be returned. As long as the top bit is set, there are more
1362          * blocks expected.
1363          *
1364          * We do not do this for AFS file servers because they sometimes
1365          * return large negative numbers as the transfer size.
1366          */
1367         if (avc->states & CForeign) {
1368             moredata = length & 0x80000000;
1369             length &= ~0x80000000;
1370         } else {
1371             moredata = 0;
1372         }
1373 #ifndef AFS_NOSTATS
1374         (*abytesToXferP) += length;
1375 #endif                          /* AFS_NOSTATS */
1376         while (length > 0) {
1377             tlen = (length > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : length);
1378             RX_AFS_GUNLOCK();
1379             code = rx_Read(acall, tbuffer, tlen);
1380             RX_AFS_GLOCK();
1381 #ifndef AFS_NOSTATS
1382             (*abytesXferredP) += code;
1383 #endif                          /* AFS_NOSTATS */
1384             if (code != tlen) {
1385                 osi_FreeLargeSpace(tbuffer);
1386                 afs_Trace3(afs_iclSetp, CM_TRACE_FETCH64READ,
1387                         ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code,
1388                         ICL_TYPE_INT32, length);
1389                 return -34;
1390             }
1391             code = afs_osi_Write(afile, -1, tbuffer, tlen);
1392             if (code != tlen) {
1393                 osi_FreeLargeSpace(tbuffer);
1394                 return EIO;
1395             }
1396             abase += tlen;
1397             length -= tlen;
1398             adc->validPos = abase;
1399             afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAKE,
1400                        ICL_TYPE_STRING, __FILE__,
1401                        ICL_TYPE_INT32, __LINE__,
1402                        ICL_TYPE_POINTER, adc,
1403                        ICL_TYPE_INT32, adc->dflags);
1404             afs_osi_Wakeup(&adc->validPos);
1405         }
1406     } while (moredata);
1407     osi_FreeLargeSpace(tbuffer);
1408     return 0;
1409
1410 } /* afs_UFSCacheFetchProc*/
1411
1412 /*
1413  * afs_GetDCache
1414  *
1415  * Description:
1416  *      This function is called to obtain a reference to data stored in
1417  *      the disk cache, locating a chunk of data containing the desired
1418  *      byte and returning a reference to the disk cache entry, with its
1419  *      reference count incremented.
1420  *
1421  * Parameters:
1422  * IN:
1423  *      avc     : Ptr to a vcache entry (unlocked)
1424  *      abyte   : Byte position in the file desired
1425  *      areq    : Request structure identifying the requesting user.
1426  *      aflags  : Settings as follows:
1427  *                      1 : Set locks
1428  *                      2 : Return after creating entry.
1429  *                      4 : called from afs_vnop_write.c
1430  *                          *alen contains length of data to be written.
1431  * OUT:
1432  *      aoffset : Set to the offset within the chunk where the resident
1433  *                byte is located.
1434  *      alen    : Set to the number of bytes of data after the desired
1435  *                byte (including the byte itself) which can be read
1436  *                from this chunk.
1437  *
1438  * Environment:
1439  *      The vcache entry pointed to by avc is unlocked upon entry.
1440  */
1441
1442 struct tlocal1 {
1443     struct AFSVolSync tsync;
1444     struct AFSFetchStatus OutStatus;
1445     struct AFSCallBack CallBack;
1446 };
1447
1448 /*
1449  * Update the vnode-to-dcache hint if we can get the vnode lock
1450  * right away.  Assumes dcache entry is at least read-locked.
1451  */
1452 void updateV2DC(int lockVc, struct vcache *v, struct dcache *d, int src)
1453 {
1454     if (!lockVc || 0 == NBObtainWriteLock(&v->lock,src)) {
1455         if (hsame(v->m.DataVersion, d->f.versionNo) && v->callback) {
1456             v->quick.dc = d;
1457             v->quick.stamp = d->stamp = MakeStamp();
1458             v->quick.minLoc = AFS_CHUNKTOBASE(d->f.chunk);
1459             /* Don't think I need these next two lines forever */
1460             v->quick.len = d->f.chunkBytes;
1461             v->h1.dchint = d;
1462         }
1463         if (lockVc) ReleaseWriteLock(&v->lock);
1464     }
1465 }
1466
1467 /* avc - Write-locked unless aflags & 1 */
1468 struct dcache *afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
1469         register struct vrequest *areq, afs_size_t *aoffset, afs_size_t *alen,
1470         int aflags)
1471 {
1472     register afs_int32 i, code, code1, shortcut , adjustsize=0;
1473     int setLocks;
1474     afs_int32 index;
1475     afs_int32 us;
1476     afs_int32 chunk;
1477     afs_size_t maxGoodLength;           /* amount of good data at server */
1478     struct rx_call *tcall;
1479     afs_size_t Position = 0;
1480 #ifdef AFS_64BIT_CLIENT
1481     afs_size_t tsize;
1482 #endif /* AFS_64BIT_CLIENT */
1483     afs_int32 size, tlen;               /* size of segment to transfer */
1484     afs_size_t lengthFound;             /* as returned from server */
1485     struct tlocal1 *tsmall = 0;
1486     register struct dcache *tdc;
1487     register struct osi_file *file;
1488     register struct conn *tc;
1489     int downDCount = 0;
1490     struct server *newCallback;
1491     char setNewCallback;
1492     char setVcacheStatus;
1493     char doVcacheUpdate;
1494     char slowPass = 0;
1495     int doAdjustSize = 0;
1496     int doReallyAdjustSize = 0;
1497     int overWriteWholeChunk = 0;
1498
1499     XSTATS_DECLS
1500 #ifndef AFS_NOSTATS
1501     struct afs_stats_xferData *xferP;   /* Ptr to this op's xfer struct */
1502     osi_timeval_t  xferStartTime,       /*FS xfer start time*/
1503                    xferStopTime;        /*FS xfer stop time*/
1504     afs_size_t bytesToXfer;                     /* # bytes to xfer*/
1505     afs_size_t bytesXferred;                    /* # bytes actually xferred*/
1506     struct afs_stats_AccessInfo *accP;  /*Ptr to access record in stats*/
1507     int fromReplica;                    /*Are we reading from a replica?*/
1508     int numFetchLoops;                  /*# times around the fetch/analyze loop*/
1509 #endif /* AFS_NOSTATS */
1510
1511     AFS_STATCNT(afs_GetDCache);
1512
1513     if (dcacheDisabled)
1514         return NULL;
1515
1516     setLocks = aflags & 1;
1517
1518     /*
1519      * Determine the chunk number and offset within the chunk corresponding
1520      * to the desired byte.
1521      */
1522     if (avc->fid.Fid.Vnode & 1) { /* if (vType(avc) == VDIR) */
1523         chunk = 0;
1524     }
1525     else {
1526         chunk = AFS_CHUNK(abyte);
1527     }
1528
1529     /* come back to here if we waited for the cache to drain. */
1530 RetryGetDCache:
1531
1532     setNewCallback = setVcacheStatus = 0;
1533
1534     if (setLocks) {
1535         if (slowPass)
1536             ObtainWriteLock(&avc->lock, 616);
1537         else
1538             ObtainReadLock(&avc->lock);
1539     }
1540
1541     /*
1542      * Locks held:
1543      * avc->lock(R) if setLocks && !slowPass
1544      * avc->lock(W) if !setLocks || slowPass
1545      */
1546
1547     shortcut = 0;
1548
1549     /* check hints first! (might could use bcmp or some such...) */
1550     if ((tdc = avc->h1.dchint)) {
1551         int dcLocked;
1552
1553         /*
1554          * The locking order between afs_xdcache and dcache lock matters.
1555          * The hint dcache entry could be anywhere, even on the free list.
1556          * Locking afs_xdcache ensures that noone is trying to pull dcache
1557          * entries from the free list, and thereby assuming them to be not
1558          * referenced and not locked.
1559          */
1560         MObtainReadLock(&afs_xdcache);
1561         dcLocked = (0 == NBObtainSharedLock(&tdc->lock, 601));
1562
1563         if (dcLocked &&
1564             (tdc->index != NULLIDX) && !FidCmp(&tdc->f.fid, &avc->fid) &&
1565             chunk == tdc->f.chunk &&
1566             !(afs_indexFlags[tdc->index] & (IFFree|IFDiscarded))) {
1567             /* got the right one.  It might not be the right version, and it
1568              * might be fetching, but it's the right dcache entry.
1569              */
1570             /* All this code should be integrated better with what follows:
1571              * I can save a good bit more time under a write lock if I do..
1572              */
1573             ObtainWriteLock(&tdc->tlock, 603);
1574             tdc->refCount++;
1575             ReleaseWriteLock(&tdc->tlock);
1576
1577             MReleaseReadLock(&afs_xdcache);
1578             shortcut = 1;
1579
1580             if (hsame(tdc->f.versionNo, avc->m.DataVersion) &&
1581                 !(tdc->dflags & DFFetching)) {
1582
1583                 afs_stats_cmperf.dcacheHits++;
1584                 MObtainWriteLock(&afs_xdcache, 559);
1585                 QRemove(&tdc->lruq);
1586                 QAdd(&afs_DLRU, &tdc->lruq);
1587                 MReleaseWriteLock(&afs_xdcache);
1588
1589                 /* Locks held:
1590                  * avc->lock(R) if setLocks && !slowPass
1591                  * avc->lock(W) if !setLocks || slowPass
1592                  * tdc->lock(S)
1593                  */
1594                 goto done;
1595             }
1596         } else {
1597             if (dcLocked) ReleaseSharedLock(&tdc->lock);
1598             MReleaseReadLock(&afs_xdcache);
1599         }
1600
1601         if (!shortcut)
1602             tdc = 0;
1603     }
1604
1605     /* Locks held:
1606      * avc->lock(R) if setLocks && !slowPass
1607      * avc->lock(W) if !setLocks || slowPass
1608      * tdc->lock(S) if tdc
1609      */
1610
1611     if (!tdc) { /* If the hint wasn't the right dcache entry */
1612         /*
1613          * Hash on the [fid, chunk] and get the corresponding dcache index
1614          * after write-locking the dcache.
1615          */
1616 RetryLookup:
1617
1618         /* Locks held:
1619          * avc->lock(R) if setLocks && !slowPass
1620          * avc->lock(W) if !setLocks || slowPass
1621          */
1622
1623         i = DCHash(&avc->fid, chunk);
1624         /* check to make sure our space is fine */
1625         afs_MaybeWakeupTruncateDaemon();
1626
1627         MObtainWriteLock(&afs_xdcache,280);
1628         us = NULLIDX;
1629         for (index = afs_dchashTbl[i]; index != NULLIDX; ) {
1630             if (afs_indexUnique[index] == avc->fid.Fid.Unique) {
1631                 tdc = afs_GetDSlot(index, NULL);
1632                 ReleaseReadLock(&tdc->tlock);
1633                 /*
1634                  * Locks held:
1635                  * avc->lock(R) if setLocks && !slowPass
1636                  * avc->lock(W) if !setLocks || slowPass
1637                  * afs_xdcache(W)
1638                  */
1639                 if (!FidCmp(&tdc->f.fid, &avc->fid) && chunk == tdc->f.chunk) {
1640                     /* Move it up in the beginning of the list */
1641                     if (afs_dchashTbl[i] != index)  {
1642                         afs_dcnextTbl[us] = afs_dcnextTbl[index];
1643                         afs_dcnextTbl[index] = afs_dchashTbl[i];
1644                         afs_dchashTbl[i] = index;
1645                     }
1646                     MReleaseWriteLock(&afs_xdcache);
1647                     ObtainSharedLock(&tdc->lock, 606);
1648                     break;  /* leaving refCount high for caller */
1649                 }
1650                 afs_PutDCache(tdc);
1651                 tdc = 0;
1652             }
1653             us = index;
1654             index = afs_dcnextTbl[index];
1655         }
1656
1657         /*
1658          * If we didn't find the entry, we'll create one.
1659          */
1660         if (index == NULLIDX) {
1661             /*
1662              * Locks held:
1663              * avc->lock(R) if setLocks
1664              * avc->lock(W) if !setLocks
1665              * afs_xdcache(W)
1666              */
1667             afs_Trace2(afs_iclSetp, CM_TRACE_GETDCACHE1, ICL_TYPE_POINTER,
1668                        avc, ICL_TYPE_INT32, chunk);
1669
1670             /* Make sure there is a free dcache entry for us to use */
1671             if (afs_discardDCList == NULLIDX && afs_freeDCList == NULLIDX) {
1672                 while (1) {
1673                     if (!setLocks) avc->states |= CDCLock;
1674                     afs_GetDownD(5, (int*)0);   /* just need slots */
1675                     if (!setLocks) avc->states &= ~CDCLock;
1676                     if (afs_discardDCList != NULLIDX || afs_freeDCList != NULLIDX)
1677                         break;
1678                     /* If we can't get space for 5 mins we give up and panic */
1679                     if (++downDCount > 300)
1680                         osi_Panic("getdcache");
1681                     MReleaseWriteLock(&afs_xdcache);
1682                     /*
1683                      * Locks held:
1684                      * avc->lock(R) if setLocks
1685                      * avc->lock(W) if !setLocks
1686                      */
1687                     afs_osi_Wait(1000, 0, 0);
1688                     goto RetryLookup;
1689                 }
1690             }
1691
1692             if (afs_discardDCList == NULLIDX ||
1693                 ((aflags & 2) && afs_freeDCList != NULLIDX)) {
1694
1695                 afs_indexFlags[afs_freeDCList] &= ~IFFree;
1696                 tdc = afs_GetDSlot(afs_freeDCList, 0);
1697                 osi_Assert(tdc->refCount == 1);
1698                 ReleaseReadLock(&tdc->tlock);
1699                 ObtainWriteLock(&tdc->lock, 604);
1700                 afs_freeDCList = afs_dvnextTbl[tdc->index];
1701                 afs_freeDCCount--;
1702             } else {
1703                 afs_indexFlags[afs_discardDCList] &= ~IFDiscarded;
1704                 tdc = afs_GetDSlot(afs_discardDCList, 0);
1705                 osi_Assert(tdc->refCount == 1);
1706                 ReleaseReadLock(&tdc->tlock);
1707                 ObtainWriteLock(&tdc->lock, 605);
1708                 afs_discardDCList = afs_dvnextTbl[tdc->index];
1709                 afs_discardDCCount--;
1710                 size = ((tdc->f.chunkBytes + afs_fsfragsize)^afs_fsfragsize)>>10;
1711                 afs_blocksDiscarded -= size;
1712                 afs_stats_cmperf.cacheBlocksDiscarded = afs_blocksDiscarded;
1713                 if (aflags & 2) {
1714                     /* Truncate the chunk so zeroes get filled properly */
1715                     file = afs_CFileOpen(tdc->f.inode);
1716                     afs_CFileTruncate(file, 0);
1717                     afs_CFileClose(file);
1718                     afs_AdjustSize(tdc, 0);
1719                 }
1720             }
1721
1722             /*
1723              * Locks held:
1724              * avc->lock(R) if setLocks
1725              * avc->lock(W) if !setLocks
1726              * tdc->lock(W)
1727              * afs_xdcache(W)
1728              */
1729
1730             /*
1731              * Fill in the newly-allocated dcache record.
1732              */
1733             afs_indexFlags[tdc->index] &= ~(IFDirtyPages | IFAnyPages);
1734             tdc->f.fid = avc->fid;
1735             afs_indexUnique[tdc->index] = tdc->f.fid.Fid.Unique;
1736             hones(tdc->f.versionNo);        /* invalid value */
1737             tdc->f.chunk = chunk;
1738             tdc->validPos = AFS_CHUNKTOBASE(chunk);
1739             /* XXX */
1740             if (tdc->lruq.prev == &tdc->lruq) osi_Panic("lruq 1");
1741
1742             /*
1743              * Now add to the two hash chains - note that i is still set
1744              * from the above DCHash call.
1745              */
1746             afs_dcnextTbl[tdc->index] = afs_dchashTbl[i];
1747             afs_dchashTbl[i] = tdc->index;
1748             i = DVHash(&avc->fid);
1749             afs_dvnextTbl[tdc->index] = afs_dvhashTbl[i];
1750             afs_dvhashTbl[i] = tdc->index;
1751             tdc->dflags = DFEntryMod;
1752             tdc->mflags = 0;
1753             tdc->f.states = 0;
1754             afs_MaybeWakeupTruncateDaemon();
1755             MReleaseWriteLock(&afs_xdcache);
1756             ConvertWToSLock(&tdc->lock);
1757         }
1758     } /* vcache->dcache hint failed */
1759
1760     /*
1761      * Locks held:
1762      * avc->lock(R) if setLocks && !slowPass
1763      * avc->lock(W) if !setLocks || slowPass
1764      * tdc->lock(S)
1765      */
1766
1767     afs_Trace4(afs_iclSetp, CM_TRACE_GETDCACHE2, ICL_TYPE_POINTER, avc,
1768                ICL_TYPE_POINTER, tdc,
1769                ICL_TYPE_INT32, hgetlo(tdc->f.versionNo),
1770                ICL_TYPE_INT32, hgetlo(avc->m.DataVersion));
1771     /*
1772      * Here we have the entry in tdc, with its refCount incremented.
1773      * Note: we don't use the S-lock on avc; it costs concurrency when
1774      * storing a file back to the server.
1775      */
1776
1777     /*
1778      * Not a newly created file so we need to check the file's length and
1779      * compare data versions since someone could have changed the data or we're
1780      * reading a file written elsewhere. We only want to bypass doing no-op
1781      * read rpcs on newly created files (dv of 0) since only then we guarantee
1782      * that this chunk's data hasn't been filled by another client.
1783      */
1784     size = AFS_CHUNKSIZE(abyte);
1785     if (aflags & 4)     /* called from write */
1786         tlen = *alen;
1787     else                /* called from read */
1788         tlen = tdc->validPos - abyte;
1789     Position = AFS_CHUNKTOBASE(chunk);
1790     afs_Trace4(afs_iclSetp, CM_TRACE_GETDCACHE3,
1791                ICL_TYPE_INT32, tlen,
1792                ICL_TYPE_INT32, aflags,
1793                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(abyte),
1794                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(Position));
1795     if ((aflags & 4) && (hiszero(avc->m.DataVersion)))
1796         doAdjustSize = 1;
1797     if ((aflags & 4) && (abyte == Position) && (tlen >= size))
1798         overWriteWholeChunk = 1;
1799     if (doAdjustSize || overWriteWholeChunk) {
1800 #if     defined(AFS_AIX32_ENV) || defined(AFS_SGI_ENV)
1801 #ifdef  AFS_SGI_ENV
1802 #ifdef AFS_SGI64_ENV
1803         if (doAdjustSize) adjustsize = NBPP;
1804 #else /* AFS_SGI64_ENV */
1805         if (doAdjustSize) adjustsize = 8192;
1806 #endif /* AFS_SGI64_ENV */
1807 #else /* AFS_SGI_ENV */
1808         if (doAdjustSize) adjustsize = 4096;
1809 #endif /* AFS_SGI_ENV */
1810         if (AFS_CHUNKTOBASE(chunk)+adjustsize >= avc->m.Length &&
1811 #else /* defined(AFS_AIX32_ENV) || defined(AFS_SGI_ENV) */
1812 #if     defined(AFS_SUN_ENV)  || defined(AFS_OSF_ENV)
1813         if ((doAdjustSize || (AFS_CHUNKTOBASE(chunk) >= avc->m.Length)) &&
1814 #else
1815         if (AFS_CHUNKTOBASE(chunk) >= avc->m.Length &&
1816 #endif
1817 #endif /* defined(AFS_AIX32_ENV) || defined(AFS_SGI_ENV) */
1818         !hsame(avc->m.DataVersion, tdc->f.versionNo))
1819             doReallyAdjustSize = 1;
1820
1821         if (doReallyAdjustSize || overWriteWholeChunk) {
1822             /* no data in file to read at this position */
1823             UpgradeSToWLock(&tdc->lock, 607);
1824
1825             file = afs_CFileOpen(tdc->f.inode);
1826             afs_CFileTruncate(file, 0);
1827             afs_CFileClose(file);
1828             afs_AdjustSize(tdc, 0);
1829             hset(tdc->f.versionNo, avc->m.DataVersion);
1830             tdc->dflags |= DFEntryMod;
1831
1832             ConvertWToSLock(&tdc->lock);
1833         }
1834     }
1835
1836     /*
1837      * We must read in the whole chunk if the version number doesn't
1838      * match.
1839      */
1840     if (aflags & 2) {
1841         /* don't need data, just a unique dcache entry */
1842         ObtainWriteLock(&afs_xdcache, 608);
1843         hset(afs_indexTimes[tdc->index], afs_indexCounter);
1844         hadd32(afs_indexCounter, 1);
1845         ReleaseWriteLock(&afs_xdcache);
1846
1847         updateV2DC(setLocks, avc, tdc, 553);
1848         if (vType(avc) == VDIR)
1849             *aoffset = abyte;
1850         else
1851             *aoffset = AFS_CHUNKOFFSET(abyte);
1852         if (tdc->validPos < abyte)
1853             *alen = (afs_size_t) 0;
1854         else
1855             *alen = tdc->validPos - abyte;
1856         ReleaseSharedLock(&tdc->lock);
1857         if (setLocks) {
1858             if (slowPass)
1859                 ReleaseWriteLock(&avc->lock);
1860             else
1861                 ReleaseReadLock(&avc->lock);
1862         }
1863         return tdc;     /* check if we're done */
1864     }
1865
1866     /*
1867      * Locks held:
1868      * avc->lock(R) if setLocks && !slowPass
1869      * avc->lock(W) if !setLocks || slowPass
1870      * tdc->lock(S)
1871      */
1872     osi_Assert((setLocks && !slowPass) || WriteLocked(&avc->lock));
1873
1874     setNewCallback = setVcacheStatus = 0;
1875
1876     /*
1877      * Locks held:
1878      * avc->lock(R) if setLocks && !slowPass
1879      * avc->lock(W) if !setLocks || slowPass
1880      * tdc->lock(S)
1881      */
1882     if (!hsame(avc->m.DataVersion, tdc->f.versionNo) && !overWriteWholeChunk) {
1883         /*
1884          * Version number mismatch.
1885          */
1886         UpgradeSToWLock(&tdc->lock, 609);
1887
1888         /*
1889          * If data ever existed for this vnode, and this is a text object,
1890          * do some clearing.  Now, you'd think you need only do the flush
1891          * when VTEXT is on, but VTEXT is turned off when the text object
1892          * is freed, while pages are left lying around in memory marked
1893          * with this vnode.  If we would reactivate (create a new text
1894          * object from) this vnode, we could easily stumble upon some of
1895          * these old pages in pagein.  So, we always flush these guys.
1896          * Sun has a wonderful lack of useful invariants in this system.
1897          *
1898          * avc->flushDV is the data version # of the file at the last text
1899          * flush.  Clearly, at least, we don't have to flush the file more
1900          * often than it changes
1901          */
1902         if (hcmp(avc->flushDV, avc->m.DataVersion) < 0) {
1903             /*
1904              * By here, the cache entry is always write-locked.  We can
1905              * deadlock if we call osi_Flush with the cache entry locked...
1906              * Unlock the dcache too.
1907              */
1908             ReleaseWriteLock(&tdc->lock);
1909             if (setLocks && !slowPass)
1910                 ReleaseReadLock(&avc->lock);
1911             else
1912                 ReleaseWriteLock(&avc->lock);
1913
1914             osi_FlushText(avc);
1915             /*
1916              * Call osi_FlushPages in open, read/write, and map, since it
1917              * is too hard here to figure out if we should lock the
1918              * pvnLock.
1919              */
1920             if (setLocks && !slowPass)
1921                 ObtainReadLock(&avc->lock);
1922             else
1923                 ObtainWriteLock(&avc->lock, 66);
1924             ObtainWriteLock(&tdc->lock, 610);
1925         }
1926
1927         /*
1928          * Locks held:
1929          * avc->lock(R) if setLocks && !slowPass
1930          * avc->lock(W) if !setLocks || slowPass
1931          * tdc->lock(W)
1932          */
1933
1934         /* Watch for standard race condition around osi_FlushText */
1935         if (hsame(avc->m.DataVersion, tdc->f.versionNo)) {
1936             updateV2DC(setLocks, avc, tdc, 569); /* set hint */
1937             afs_stats_cmperf.dcacheHits++;
1938             ConvertWToSLock(&tdc->lock);
1939             goto done;
1940         }
1941
1942         /* Sleep here when cache needs to be drained. */
1943         if (setLocks && !slowPass &&
1944             (afs_blocksUsed > (CM_WAITFORDRAINPCT*afs_cacheBlocks)/100)) {
1945             /* Make sure truncate daemon is running */
1946             afs_MaybeWakeupTruncateDaemon();
1947             ObtainWriteLock(&tdc->tlock, 614);
1948             tdc->refCount--; /* we'll re-obtain the dcache when we re-try. */
1949             ReleaseWriteLock(&tdc->tlock);
1950             ReleaseWriteLock(&tdc->lock);
1951             ReleaseReadLock(&avc->lock);
1952             while ((afs_blocksUsed-afs_blocksDiscarded) >
1953                    (CM_WAITFORDRAINPCT*afs_cacheBlocks)/100) {
1954                 afs_WaitForCacheDrain = 1;
1955                 afs_osi_Sleep(&afs_WaitForCacheDrain);
1956             }
1957             afs_MaybeFreeDiscardedDCache();
1958             /* need to check if someone else got the chunk first. */
1959             goto RetryGetDCache;
1960         }
1961
1962         /* Do not fetch data beyond truncPos. */
1963         maxGoodLength = avc->m.Length;
1964         if (avc->truncPos < maxGoodLength) maxGoodLength = avc->truncPos;
1965         Position = AFS_CHUNKBASE(abyte);
1966         if (vType(avc) == VDIR) {
1967             size = avc->m.Length;
1968             if (size > tdc->f.chunkBytes) {
1969                 /* pre-reserve space for file */
1970                 afs_AdjustSize(tdc, size);
1971             }
1972             size = 999999999;       /* max size for transfer */
1973         }
1974         else {
1975             size = AFS_CHUNKSIZE(abyte);        /* expected max size */
1976             /* don't read past end of good data on server */
1977             if (Position + size > maxGoodLength)
1978                 size = maxGoodLength - Position;
1979             if (size < 0) size = 0; /* Handle random races */
1980             if (size > tdc->f.chunkBytes) {
1981                 /* pre-reserve space for file */
1982                 afs_AdjustSize(tdc, size);      /* changes chunkBytes */
1983                 /* max size for transfer still in size */
1984             }
1985         }
1986         if (afs_mariner && !tdc->f.chunk)
1987             afs_MarinerLog("fetch$Fetching", avc); /* , Position, size, afs_indexCounter );*/
1988         /*
1989          * Right now, we only have one tool, and it's a hammer.  So, we
1990          * fetch the whole file.
1991          */
1992         DZap(&tdc->f.inode);    /* pages in cache may be old */
1993 #ifdef  IHINT
1994         if (file = tdc->ihint) {
1995           if (tdc->f.inode == file->inum )
1996             usedihint++;
1997           else {
1998             tdc->ihint = 0;
1999             afs_UFSClose(file);
2000             file = 0;
2001             nihints--;
2002             file = osi_UFSOpen(tdc->f.inode);
2003           }
2004         }
2005         else
2006 #endif /* IHINT */
2007         file = afs_CFileOpen(tdc->f.inode);
2008         afs_RemoveVCB(&avc->fid);
2009         tdc->f.states |= DWriting;
2010         tdc->dflags |= DFFetching;
2011         tdc->validPos = Position;       /*  which is AFS_CHUNKBASE(abyte) */
2012         if (tdc->mflags & DFFetchReq) {
2013             tdc->mflags &= ~DFFetchReq;
2014             afs_osi_Wakeup(&tdc->validPos);
2015         }
2016         tsmall = (struct tlocal1 *) osi_AllocLargeSpace(sizeof(struct tlocal1));
2017         setVcacheStatus = 0;
2018 #ifndef AFS_NOSTATS
2019         /*
2020          * Remember if we are doing the reading from a replicated volume,
2021          * and how many times we've zipped around the fetch/analyze loop.
2022          */
2023         fromReplica = (avc->states & CRO) ? 1 : 0;
2024         numFetchLoops = 0;
2025         accP = &(afs_stats_cmfullperf.accessinf);
2026         if (fromReplica)
2027             (accP->replicatedRefs)++;
2028         else
2029             (accP->unreplicatedRefs)++;
2030 #endif /* AFS_NOSTATS */
2031         /* this is a cache miss */
2032         afs_Trace4(afs_iclSetp, CM_TRACE_FETCHPROC, ICL_TYPE_POINTER, avc,
2033                         ICL_TYPE_FID, &(avc->fid),
2034                         ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(Position),
2035                         ICL_TYPE_INT32, size);
2036
2037         if (size) afs_stats_cmperf.dcacheMisses++;
2038         code = 0;
2039         /*
2040          * Dynamic root support:  fetch data from local memory.
2041          */
2042         if (afs_IsDynroot(avc)) {
2043             char *dynrootDir;
2044             int dynrootLen;
2045
2046             afs_GetDynroot(&dynrootDir, &dynrootLen, &tsmall->OutStatus);
2047
2048             dynrootDir += Position;
2049             dynrootLen -= Position;
2050             if (size > dynrootLen)
2051                 size = dynrootLen;
2052             if (size < 0) size = 0;
2053             code = afs_CFileWrite(file, 0, dynrootDir, size);
2054             afs_PutDynroot();
2055
2056             if (code == size)
2057                 code = 0;
2058             else
2059                 code = -1;
2060
2061             tdc->validPos = Position + size;
2062             afs_CFileTruncate(file, size); /* prune it */
2063         } else
2064         /*
2065          * Not a dynamic vnode:  do the real fetch.
2066          */
2067         do {
2068             /*
2069              * Locks held:
2070              * avc->lock(R) if setLocks && !slowPass
2071              * avc->lock(W) if !setLocks || slowPass
2072              * tdc->lock(W)
2073              */
2074
2075             tc = afs_Conn(&avc->fid, areq, SHARED_LOCK);
2076             if (tc) {
2077                 afs_int32 length_hi, length, bytes;
2078 #ifndef AFS_NOSTATS
2079                 numFetchLoops++;
2080                 if (fromReplica)
2081                     (accP->numReplicasAccessed)++;
2082
2083 #endif /* AFS_NOSTATS */
2084                 if (!setLocks || slowPass) {
2085                     avc->callback = tc->srvr->server;
2086                 } else {
2087                     newCallback = tc->srvr->server;
2088                     setNewCallback = 1;
2089                 }
2090                 i = osi_Time();
2091                 RX_AFS_GUNLOCK();
2092                 tcall = rx_NewCall(tc->id);
2093                 RX_AFS_GLOCK();
2094
2095                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_FETCHDATA);
2096 #ifdef AFS_64BIT_CLIENT
2097                 length_hi = code = 0;
2098                 if (!afs_serverHasNo64Bit(tc)) {
2099                     tsize = size;
2100                     RX_AFS_GUNLOCK();
2101                     code = StartRXAFS_FetchData64(tcall,
2102                                             (struct AFSFid *) &avc->fid.Fid,
2103                                             Position, tsize);
2104                     if (code != 0) {
2105                         RX_AFS_GLOCK();
2106                         afs_Trace2(afs_iclSetp, CM_TRACE_FETCH64CODE,
2107                                    ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code);
2108                     } else {
2109                         bytes = rx_Read(tcall, (char *)&length_hi, sizeof(afs_int32));
2110                         RX_AFS_GLOCK();
2111                         afs_Trace2(afs_iclSetp, CM_TRACE_FETCH64CODE,
2112                                    ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code);
2113                         if (bytes == sizeof(afs_int32)) {
2114                             length_hi = ntohl(length_hi);
2115                         } else {
2116                             length_hi = 0;
2117                             code = rx_Error(tcall);
2118                             RX_AFS_GUNLOCK();
2119                             code1 = rx_EndCall(tcall, code);
2120                             RX_AFS_GLOCK();
2121                             tcall = (struct rx_call *) 0;
2122                         }
2123                     }
2124                 }
2125                 if (code == RXGEN_OPCODE || afs_serverHasNo64Bit(tc)) {
2126                     if (Position > 0x7FFFFFFF) {
2127                         code = EFBIG;
2128                     } else {
2129                         afs_int32 pos;
2130                         pos = Position;
2131                         RX_AFS_GUNLOCK();
2132                         if (!tcall)
2133                             tcall = rx_NewCall(tc->id);
2134                         code = StartRXAFS_FetchData(tcall,
2135                                     (struct AFSFid *) &avc->fid.Fid, pos, size);
2136                         RX_AFS_GLOCK();
2137                     }
2138                     afs_serverSetNo64Bit(tc);
2139                 }
2140                 if (code == 0) {
2141                     RX_AFS_GUNLOCK();
2142                     bytes = rx_Read(tcall, (char *)&length, sizeof(afs_int32));
2143                     RX_AFS_GLOCK();
2144                     if (bytes == sizeof(afs_int32)) {
2145                         length = ntohl(length);
2146                     } else {
2147                         code = rx_Error(tcall);
2148                     }
2149                 }
2150                 FillInt64(lengthFound, length_hi, length);
2151                 afs_Trace3(afs_iclSetp, CM_TRACE_FETCH64LENG,
2152                         ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code,
2153                         ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(lengthFound));
2154 #else /* AFS_64BIT_CLIENT */
2155                 RX_AFS_GUNLOCK();
2156                 code = StartRXAFS_FetchData(tcall,
2157                                             (struct AFSFid *) &avc->fid.Fid,
2158                                             Position, size);
2159                 RX_AFS_GLOCK();
2160                 if (code == 0) {
2161                     RX_AFS_GUNLOCK();
2162                     bytes = rx_Read(tcall, (char *)&length, sizeof(afs_int32));
2163                     RX_AFS_GLOCK();
2164                     if (bytes == sizeof(afs_int32)) {
2165                         length = ntohl(length);
2166                     } else {
2167                         code = rx_Error(tcall);
2168                     }
2169                 }
2170 #endif /* AFS_64BIT_CLIENT */
2171                 if (code == 0) {
2172
2173 #ifndef AFS_NOSTATS
2174                     xferP = &(afs_stats_cmfullperf.rpc.fsXferTimes[AFS_STATS_FS_XFERIDX_FETCHDATA]);
2175                     osi_GetuTime(&xferStartTime);
2176
2177                     code = afs_CacheFetchProc(tcall, file,
2178                                 (afs_size_t) Position, tdc, avc,
2179                                 &bytesToXfer, &bytesXferred, length);
2180
2181                     osi_GetuTime(&xferStopTime);
2182                     (xferP->numXfers)++;
2183                     if (!code) {
2184                         (xferP->numSuccesses)++;
2185                         afs_stats_XferSumBytes[AFS_STATS_FS_XFERIDX_FETCHDATA] += bytesXferred;
2186                         (xferP->sumBytes) += (afs_stats_XferSumBytes[AFS_STATS_FS_XFERIDX_FETCHDATA] >> 10);
2187                         afs_stats_XferSumBytes[AFS_STATS_FS_XFERIDX_FETCHDATA] &= 0x3FF;
2188                         if (bytesXferred < xferP->minBytes)
2189                            xferP->minBytes = bytesXferred;
2190                         if (bytesXferred > xferP->maxBytes)
2191                            xferP->maxBytes = bytesXferred;
2192
2193                         /*
2194                          * Tally the size of the object.  Note: we tally the actual size,
2195                          * NOT the number of bytes that made it out over the wire.
2196                          */
2197                         if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET0)
2198                             (xferP->count[0])++;
2199                         else
2200                             if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET1)
2201                                 (xferP->count[1])++;
2202                         else
2203                             if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET2)
2204                                 (xferP->count[2])++;
2205                         else
2206                             if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET3)
2207                                 (xferP->count[3])++;
2208                         else
2209                             if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET4)
2210                                 (xferP->count[4])++;
2211                         else
2212                             if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET5)
2213                                 (xferP->count[5])++;
2214                         else
2215                             if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET6)
2216                                 (xferP->count[6])++;
2217                         else
2218                             if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET7)
2219                                 (xferP->count[7])++;
2220                         else
2221                             (xferP->count[8])++;
2222
2223                         afs_stats_GetDiff(elapsedTime, xferStartTime, xferStopTime);
2224                         afs_stats_AddTo((xferP->sumTime), elapsedTime);
2225                         afs_stats_SquareAddTo((xferP->sqrTime), elapsedTime);
2226                         if (afs_stats_TimeLessThan(elapsedTime, (xferP->minTime))) {
2227                            afs_stats_TimeAssign((xferP->minTime), elapsedTime);
2228                         }
2229                         if (afs_stats_TimeGreaterThan(elapsedTime, (xferP->maxTime))) {
2230                            afs_stats_TimeAssign((xferP->maxTime), elapsedTime);
2231                         }
2232                     }
2233 #else
2234                     code = afs_CacheFetchProc(tcall, file, Position, tdc, avc, 0, 0, length);
2235 #endif /* AFS_NOSTATS */
2236                 }
2237                 if (code == 0) {
2238                     RX_AFS_GUNLOCK();
2239                     code = EndRXAFS_FetchData(tcall,
2240                                               &tsmall->OutStatus,
2241                                               &tsmall->CallBack,
2242                                               &tsmall->tsync);
2243                     RX_AFS_GLOCK();
2244                 }
2245                 XSTATS_END_TIME;
2246                 RX_AFS_GUNLOCK();
2247                 if (tcall)
2248                     code1 = rx_EndCall(tcall, code);
2249                 RX_AFS_GLOCK();
2250             }
2251             else {
2252                 code = -1;
2253             }
2254             if ( !code && code1 )
2255                 code = code1;
2256
2257             if (code == 0) {
2258                 /* callback could have been broken (or expired) in a race here,
2259                  * but we return the data anyway.  It's as good as we knew about
2260                  * when we started. */
2261                 /*
2262                  * validPos is updated by CacheFetchProc, and can only be
2263                  * modifed under a dcache write lock, which we've blocked out
2264                  */
2265                 size = tdc->validPos - Position;  /* actual segment size */
2266                 if (size < 0) size = 0;
2267                 afs_CFileTruncate(file, size); /* prune it */
2268             }
2269             else {
2270                 if (!setLocks || slowPass) {
2271                     ObtainWriteLock(&afs_xcbhash, 453);
2272                     afs_DequeueCallback(avc);
2273                     avc->states &= ~(CStatd | CUnique);
2274                     avc->callback = NULL;
2275                     ReleaseWriteLock(&afs_xcbhash);
2276                     if (avc->fid.Fid.Vnode & 1 || (vType(avc) == VDIR))
2277                         osi_dnlc_purgedp(avc);
2278                 } else {
2279                     /* Something lost.  Forget about performance, and go
2280                      * back with a vcache write lock.
2281                      */
2282                     afs_CFileTruncate(file, 0);
2283                     afs_AdjustSize(tdc, 0);
2284                     afs_CFileClose(file);
2285                     osi_FreeLargeSpace(tsmall);
2286                     tsmall = 0;
2287                     ReleaseWriteLock(&tdc->lock);
2288                     afs_PutDCache(tdc);
2289                     tdc = 0;
2290                     ReleaseReadLock(&avc->lock);
2291                     slowPass = 1;
2292                     goto RetryGetDCache;
2293                 }
2294             }
2295
2296         } while
2297             (afs_Analyze(tc, code, &avc->fid, areq,
2298                          AFS_STATS_FS_RPCIDX_FETCHDATA,
2299                          SHARED_LOCK, NULL));
2300
2301         /*
2302          * Locks held:
2303          * avc->lock(R) if setLocks && !slowPass
2304          * avc->lock(W) if !setLocks || slowPass
2305          * tdc->lock(W)
2306          */
2307
2308 #ifndef AFS_NOSTATS
2309         /*
2310          * In the case of replicated access, jot down info on the number of
2311          * attempts it took before we got through or gave up.
2312          */
2313         if (fromReplica) {
2314             if (numFetchLoops <= 1)
2315                 (accP->refFirstReplicaOK)++;
2316             if (numFetchLoops > accP->maxReplicasPerRef)
2317                 accP->maxReplicasPerRef = numFetchLoops;
2318         }
2319 #endif /* AFS_NOSTATS */
2320
2321         tdc->dflags &= ~DFFetching;
2322         afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAKE,
2323                    ICL_TYPE_STRING, __FILE__,
2324                    ICL_TYPE_INT32, __LINE__,
2325                    ICL_TYPE_POINTER, tdc,
2326                    ICL_TYPE_INT32, tdc->dflags);
2327         afs_osi_Wakeup(&tdc->validPos);
2328         if (avc->execsOrWriters == 0) tdc->f.states &= ~DWriting;
2329
2330         /* now, if code != 0, we have an error and should punt.
2331          * note that we have the vcache write lock, either because
2332          * !setLocks or slowPass.
2333          */
2334         if (code) {
2335             afs_CFileTruncate(file, 0);
2336             afs_AdjustSize(tdc, 0);
2337             afs_CFileClose(file);
2338             ZapDCE(tdc);        /* sets DFEntryMod */
2339             if (vType(avc) == VDIR) {
2340                 DZap(&tdc->f.inode);
2341             }
2342             ReleaseWriteLock(&tdc->lock);
2343             afs_PutDCache(tdc);
2344             ObtainWriteLock(&afs_xcbhash, 454);
2345             afs_DequeueCallback(avc);
2346             avc->states &= ~( CStatd | CUnique );
2347             ReleaseWriteLock(&afs_xcbhash);
2348             if (avc->fid.Fid.Vnode & 1 || (vType(avc) == VDIR))
2349                 osi_dnlc_purgedp(avc);
2350             /*
2351              * Locks held:
2352              * avc->lock(W); assert(!setLocks || slowPass)
2353              */
2354             osi_Assert(!setLocks || slowPass);
2355             tdc = NULL;
2356             goto done;
2357         }
2358
2359         /* otherwise we copy in the just-fetched info */
2360         afs_CFileClose(file);
2361         afs_AdjustSize(tdc, size);  /* new size */
2362         /*
2363          * Copy appropriate fields into vcache.  Status is
2364          * copied later where we selectively acquire the
2365          * vcache write lock.
2366          */
2367         if (slowPass)
2368             afs_ProcessFS(avc, &tsmall->OutStatus, areq);
2369         else
2370             setVcacheStatus = 1;
2371         hset64(tdc->f.versionNo, tsmall->OutStatus.dataVersionHigh, tsmall->OutStatus.DataVersion);
2372         tdc->dflags |= DFEntryMod;
2373         afs_indexFlags[tdc->index] |= IFEverUsed;
2374         ConvertWToSLock(&tdc->lock);
2375     } /*Data version numbers don't match*/
2376     else {
2377         /*
2378          * Data version numbers match.
2379          */
2380         afs_stats_cmperf.dcacheHits++;
2381     }  /*Data version numbers match*/
2382
2383     updateV2DC(setLocks, avc, tdc, 335); /* set hint */
2384 done:
2385     /*
2386      * Locks held:
2387      * avc->lock(R) if setLocks && !slowPass
2388      * avc->lock(W) if !setLocks || slowPass
2389      * tdc->lock(S) if tdc
2390      */
2391
2392     /*
2393      * See if this was a reference to a file in the local cell.
2394      */
2395     if (afs_IsPrimaryCellNum(avc->fid.Cell))
2396         afs_stats_cmperf.dlocalAccesses++;
2397     else
2398         afs_stats_cmperf.dremoteAccesses++;
2399
2400     /* Fix up LRU info */
2401
2402     if (tdc) {
2403         MObtainWriteLock(&afs_xdcache, 602);
2404         hset(afs_indexTimes[tdc->index], afs_indexCounter);
2405         hadd32(afs_indexCounter, 1);
2406         MReleaseWriteLock(&afs_xdcache);
2407
2408         /* return the data */
2409         if (vType(avc) == VDIR)
2410             *aoffset = abyte;
2411         else
2412             *aoffset = AFS_CHUNKOFFSET(abyte);
2413         *alen = (tdc->f.chunkBytes - *aoffset);
2414         ReleaseSharedLock(&tdc->lock);
2415     }
2416
2417     /*
2418      * Locks held:
2419      * avc->lock(R) if setLocks && !slowPass
2420      * avc->lock(W) if !setLocks || slowPass
2421      */
2422
2423     /* Fix up the callback and status values in the vcache */
2424     doVcacheUpdate = 0;
2425     if (setLocks && !slowPass) {
2426         /* DCLOCKXXX
2427          *
2428          * This is our dirty little secret to parallel fetches.
2429          * We don't write-lock the vcache while doing the fetch,
2430          * but potentially we'll need to update the vcache after
2431          * the fetch is done.
2432          *
2433          * Drop the read lock and try to re-obtain the write
2434          * lock.  If the vcache still has the same DV, it's
2435          * ok to go ahead and install the new data.
2436          */
2437         afs_hyper_t currentDV, statusDV;
2438
2439         hset(currentDV, avc->m.DataVersion);
2440
2441         if (setNewCallback && avc->callback != newCallback)
2442             doVcacheUpdate = 1;
2443
2444         if (tsmall) {
2445             hset64(statusDV, tsmall->OutStatus.dataVersionHigh,
2446                              tsmall->OutStatus.DataVersion);
2447
2448             if (setVcacheStatus && avc->m.Length != tsmall->OutStatus.Length)
2449                 doVcacheUpdate = 1;
2450             if (setVcacheStatus && !hsame(currentDV, statusDV))
2451                 doVcacheUpdate = 1;
2452         }
2453
2454         ReleaseReadLock(&avc->lock);
2455
2456         if (doVcacheUpdate) {
2457             ObtainWriteLock(&avc->lock, 615);
2458             if (!hsame(avc->m.DataVersion, currentDV)) {
2459                 /* We lose.  Someone will beat us to it. */
2460                 doVcacheUpdate = 0;
2461                 ReleaseWriteLock(&avc->lock);
2462             }
2463         }
2464     }
2465
2466     /* With slow pass, we've already done all the updates */
2467     if (slowPass) {
2468         ReleaseWriteLock(&avc->lock);
2469     }
2470
2471     /* Check if we need to perform any last-minute fixes with a write-lock */
2472     if (!setLocks || doVcacheUpdate) {
2473         if (setNewCallback) avc->callback = newCallback;
2474         if (tsmall && setVcacheStatus) afs_ProcessFS(avc, &tsmall->OutStatus, areq);
2475         if (setLocks) ReleaseWriteLock(&avc->lock);
2476     }
2477
2478     if (tsmall) osi_FreeLargeSpace(tsmall);
2479
2480     return tdc;
2481 } /*afs_GetDCache*/
2482
2483
2484 /*
2485  * afs_WriteThroughDSlots
2486  *
2487  * Description:
2488  *      Sweep through the dcache slots and write out any modified
2489  *      in-memory data back on to our caching store.
2490  *
2491  * Parameters:
2492  *      None.
2493  *
2494  * Environment:
2495  *      The afs_xdcache is write-locked through this whole affair.
2496  */
2497 void afs_WriteThroughDSlots(void)
2498 {
2499     register struct dcache *tdc;
2500     register afs_int32 i, touchedit=0;
2501     struct dcache **ents;
2502     int entmax, entcount;
2503
2504     AFS_STATCNT(afs_WriteThroughDSlots);
2505
2506     /*
2507      * Because of lock ordering, we can't grab dcache locks while
2508      * holding afs_xdcache.  So we enter xdcache, get a reference
2509      * for every dcache entry, and exit xdcache.
2510      */
2511     MObtainWriteLock(&afs_xdcache,283);
2512     entmax = afs_cacheFiles;
2513     ents = afs_osi_Alloc(entmax * sizeof(struct dcache *));
2514     entcount = 0;
2515     for(i = 0; i < afs_cacheFiles; i++) {
2516         tdc = afs_indexTable[i];
2517
2518         /* Grab tlock in case the existing refcount isn't zero */
2519         if (tdc && !(afs_indexFlags[i] & (IFFree | IFDiscarded))) {
2520             ObtainWriteLock(&tdc->tlock, 623);
2521             tdc->refCount++;
2522             ReleaseWriteLock(&tdc->tlock);
2523
2524             ents[entcount++] = tdc;
2525         }
2526     }
2527     MReleaseWriteLock(&afs_xdcache);
2528
2529     /*
2530      * Now, for each dcache entry we found, check if it's dirty.
2531      * If so, get write-lock, get afs_xdcache, which protects
2532      * afs_cacheInodep, and flush it.  Don't forget to put back
2533      * the refcounts.
2534      */
2535     for (i = 0; i < entcount; i++) {
2536         tdc = ents[i];
2537
2538         if (tdc->dflags & DFEntryMod) {
2539             int wrLock;
2540
2541             wrLock = (0 == NBObtainWriteLock(&tdc->lock, 619));
2542
2543             /* Now that we have the write lock, double-check */
2544             if (wrLock && (tdc->dflags & DFEntryMod)) {
2545                 tdc->dflags &= ~DFEntryMod;
2546                 MObtainWriteLock(&afs_xdcache, 620);
2547                 afs_WriteDCache(tdc, 1);
2548                 MReleaseWriteLock(&afs_xdcache);
2549                 touchedit = 1;
2550             }
2551             if (wrLock) ReleaseWriteLock(&tdc->lock);
2552         }
2553
2554         afs_PutDCache(tdc);
2555     }
2556     afs_osi_Free(ents, entmax * sizeof(struct dcache *));
2557
2558     MObtainWriteLock(&afs_xdcache, 617);
2559     if (!touchedit && (cacheDiskType != AFS_FCACHE_TYPE_MEM)) {
2560         /* Touch the file to make sure that the mtime on the file is kept
2561          * up-to-date to avoid losing cached files on cold starts because
2562          * their mtime seems old...
2563          */
2564         struct afs_fheader theader;
2565
2566         theader.magic = AFS_FHMAGIC;
2567         theader.firstCSize = AFS_FIRSTCSIZE;
2568         theader.otherCSize = AFS_OTHERCSIZE;
2569         theader.version = AFS_CI_VERSION;
2570         afs_osi_Write(afs_cacheInodep, 0, &theader, sizeof(theader));
2571     }
2572     MReleaseWriteLock(&afs_xdcache);
2573 }
2574
2575 /*
2576  * afs_MemGetDSlot
2577  *
2578  * Description:
2579  *      Return a pointer to an freshly initialized dcache entry using
2580  *      a memory-based cache.  The tlock will be read-locked.
2581  *
2582  * Parameters:
2583  *      aslot : Dcache slot to look at.
2584  *      tmpdc : Ptr to dcache entry.
2585  *
2586  * Environment:
2587  *      Must be called with afs_xdcache write-locked.
2588  */
2589
2590 struct dcache *afs_MemGetDSlot(register afs_int32 aslot, register struct dcache *tmpdc)
2591 {
2592     register afs_int32 code;
2593     register struct dcache *tdc;
2594     register char *tfile;
2595     int existing = 0;
2596
2597     AFS_STATCNT(afs_MemGetDSlot);
2598     if (CheckLock(&afs_xdcache) != -1) osi_Panic("getdslot nolock");
2599     if (aslot < 0 || aslot >= afs_cacheFiles) osi_Panic("getdslot slot");
2600     tdc = afs_indexTable[aslot];
2601     if (tdc) {
2602         QRemove(&tdc->lruq);        /* move to queue head */
2603         QAdd(&afs_DLRU, &tdc->lruq);
2604         /* We're holding afs_xdcache, but get tlock in case refCount != 0 */
2605         ObtainWriteLock(&tdc->tlock, 624);
2606         tdc->refCount++;
2607         ConvertWToRLock(&tdc->tlock);
2608         return tdc;
2609     }
2610     if (tmpdc == NULL) {
2611         if (!afs_freeDSList) afs_GetDownDSlot(4);
2612         if (!afs_freeDSList) {
2613             /* none free, making one is better than a panic */
2614             afs_stats_cmperf.dcacheXAllocs++;   /* count in case we have a leak */
2615             tdc = (struct dcache *) afs_osi_Alloc(sizeof (struct dcache));
2616 #ifdef  KERNEL_HAVE_PIN
2617             pin((char *)tdc, sizeof(struct dcache));    /* XXX */
2618 #endif
2619         } else {
2620             tdc = afs_freeDSList;
2621             afs_freeDSList = (struct dcache *) tdc->lruq.next;
2622             existing = 1;
2623         }
2624         tdc->dflags = 0;        /* up-to-date, not in free q */
2625         tdc->mflags = 0;
2626         QAdd(&afs_DLRU, &tdc->lruq);
2627         if (tdc->lruq.prev == &tdc->lruq) osi_Panic("lruq 3");
2628     }
2629     else {
2630         tdc = tmpdc;
2631         tdc->f.states = 0;
2632     }
2633
2634     /* initialize entry */
2635     tdc->f.fid.Cell = 0;
2636     tdc->f.fid.Fid.Volume = 0;
2637     tdc->f.chunk = -1;
2638     hones(tdc->f.versionNo);
2639     tdc->f.inode = aslot;
2640     tdc->dflags |= DFEntryMod;
2641     tdc->refCount = 1;
2642     tdc->index = aslot;
2643     afs_indexUnique[aslot] = tdc->f.fid.Fid.Unique;
2644
2645     if (existing) {
2646         osi_Assert(0 == NBObtainWriteLock(&tdc->lock, 674));
2647         osi_Assert(0 == NBObtainWriteLock(&tdc->mflock, 675));
2648         osi_Assert(0 == NBObtainWriteLock(&tdc->tlock, 676));
2649     }
2650
2651     RWLOCK_INIT(&tdc->lock, "dcache lock");
2652     RWLOCK_INIT(&tdc->tlock, "dcache tlock");
2653     RWLOCK_INIT(&tdc->mflock, "dcache flock");
2654     ObtainReadLock(&tdc->tlock);
2655
2656     if (tmpdc == NULL)
2657         afs_indexTable[aslot] = tdc;
2658     return tdc;
2659
2660 } /*afs_MemGetDSlot*/
2661
2662 unsigned int last_error = 0, lasterrtime = 0;
2663
2664 /*
2665  * afs_UFSGetDSlot
2666  *
2667  * Description:
2668  *      Return a pointer to an freshly initialized dcache entry using
2669  *      a UFS-based disk cache.  The dcache tlock will be read-locked.
2670  *
2671  * Parameters:
2672  *      aslot : Dcache slot to look at.
2673  *      tmpdc : Ptr to dcache entry.
2674  *
2675  * Environment:
2676  *      afs_xdcache lock write-locked.
2677  */
2678 struct dcache *afs_UFSGetDSlot(register afs_int32 aslot, register struct dcache *tmpdc)
2679 {
2680     register afs_int32 code;
2681     register struct dcache *tdc;
2682     int existing = 0;
2683     int entryok;
2684
2685     AFS_STATCNT(afs_UFSGetDSlot);
2686     if (CheckLock(&afs_xdcache) != -1) osi_Panic("getdslot nolock");
2687     if (aslot < 0 || aslot >= afs_cacheFiles) osi_Panic("getdslot slot");
2688     tdc = afs_indexTable[aslot];
2689     if (tdc) {
2690         QRemove(&tdc->lruq);        /* move to queue head */
2691         QAdd(&afs_DLRU, &tdc->lruq);
2692         /* Grab tlock in case refCount != 0 */
2693         ObtainWriteLock(&tdc->tlock, 625);
2694         tdc->refCount++;
2695         ConvertWToRLock(&tdc->tlock);
2696         return tdc;
2697     }
2698     /* otherwise we should read it in from the cache file */
2699     /*
2700      * If we weren't passed an in-memory region to place the file info,
2701      * we have to allocate one.
2702      */
2703     if (tmpdc == NULL) {
2704         if (!afs_freeDSList) afs_GetDownDSlot(4);
2705         if (!afs_freeDSList) {
2706             /* none free, making one is better than a panic */
2707             afs_stats_cmperf.dcacheXAllocs++;   /* count in case we have a leak */
2708             tdc = (struct dcache *) afs_osi_Alloc(sizeof (struct dcache));
2709 #ifdef  KERNEL_HAVE_PIN
2710             pin((char *)tdc, sizeof(struct dcache));    /* XXX */
2711 #endif
2712         } else {
2713             tdc = afs_freeDSList;
2714             afs_freeDSList = (struct dcache *) tdc->lruq.next;
2715             existing = 1;
2716         }
2717         tdc->dflags = 0;        /* up-to-date, not in free q */
2718         tdc->mflags = 0;
2719         QAdd(&afs_DLRU, &tdc->lruq);
2720         if (tdc->lruq.prev == &tdc->lruq) osi_Panic("lruq 3");
2721     }
2722     else {
2723         tdc = tmpdc;
2724         tdc->f.states = 0;
2725         tdc->ihint = 0;
2726     }
2727
2728     /*
2729       * Seek to the aslot'th entry and read it in.
2730       */
2731     code = afs_osi_Read(afs_cacheInodep, sizeof(struct fcache) * aslot +
2732                                          sizeof(struct afs_fheader),
2733                         (char *)(&tdc->f), sizeof(struct fcache));
2734     entryok = 1;
2735     if (code != sizeof(struct fcache))
2736         entryok = 0;
2737     if (!afs_CellNumValid(tdc->f.fid.Cell))
2738         entryok = 0;
2739
2740     if (!entryok) {
2741         tdc->f.fid.Cell = 0;
2742         tdc->f.fid.Fid.Volume = 0;
2743         tdc->f.chunk = -1;
2744         hones(tdc->f.versionNo);
2745         tdc->dflags |= DFEntryMod;
2746 #if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
2747         last_error = getuerror();
2748 #endif
2749         lasterrtime = osi_Time();
2750         afs_indexUnique[aslot] = tdc->f.fid.Fid.Unique;
2751     }
2752     tdc->refCount = 1;
2753     tdc->index = aslot;
2754
2755     if (existing) {
2756         osi_Assert(0 == NBObtainWriteLock(&tdc->lock, 674));
2757         osi_Assert(0 == NBObtainWriteLock(&tdc->mflock, 675));
2758         osi_Assert(0 == NBObtainWriteLock(&tdc->tlock, 676));
2759     }
2760
2761     RWLOCK_INIT(&tdc->lock, "dcache lock");
2762     RWLOCK_INIT(&tdc->tlock, "dcache tlock");
2763     RWLOCK_INIT(&tdc->mflock, "dcache flock");
2764     ObtainReadLock(&tdc->tlock);
2765
2766     /*
2767      * If we didn't read into a temporary dcache region, update the
2768      * slot pointer table.
2769      */
2770     if (tmpdc == NULL)
2771         afs_indexTable[aslot] = tdc;
2772     return tdc;
2773
2774 }  /*afs_UFSGetDSlot*/
2775
2776
2777
2778 /*
2779  * afs_WriteDCache
2780  *
2781  * Description:
2782  *      write a particular dcache entry back to its home in the
2783  *      CacheInfo file.
2784  *
2785  * Parameters:
2786  *      adc   : Pointer to the dcache entry to write.
2787  *      atime : If true, set the modtime on the file to the current time.
2788  *
2789  * Environment:
2790  *      Must be called with the afs_xdcache lock at least read-locked,
2791  *      and dcache entry at least read-locked.
2792  *      The reference count is not changed.
2793  */
2794
2795 int afs_WriteDCache(register struct dcache *adc, int atime)
2796 {
2797     register struct osi_file *tfile;
2798     register afs_int32 code;
2799
2800     if (cacheDiskType == AFS_FCACHE_TYPE_MEM) return 0;
2801     AFS_STATCNT(afs_WriteDCache);
2802     if (atime)
2803         adc->f.modTime = osi_Time();
2804     /*
2805      * Seek to the right dcache slot and write the in-memory image out to disk.
2806      */
2807     afs_cellname_write();
2808     code = afs_osi_Write(afs_cacheInodep, sizeof(struct fcache) * adc->index +
2809                                           sizeof(struct afs_fheader),
2810                          (char *)(&adc->f), sizeof(struct fcache));
2811     if (code != sizeof(struct fcache)) return EIO;
2812     return 0;
2813 }
2814
2815
2816
2817 /*
2818  * afs_wakeup
2819  *
2820  * Description:
2821  *      Wake up users of a particular file waiting for stores to take
2822  *      place.
2823  *
2824  * Parameters:
2825  *      avc : Ptr to related vcache entry.
2826  *
2827  * Environment:
2828  *      Nothing interesting.
2829  */
2830
2831 int afs_wakeup(register struct vcache *avc)
2832 {
2833     register int i;
2834     register struct brequest *tb;
2835     tb = afs_brs;
2836     AFS_STATCNT(afs_wakeup);
2837     for (i = 0; i < NBRS; i++, tb++) {
2838         /* if request is valid and for this file, we've found it */
2839         if (tb->refCount > 0 && avc == tb->vnode) {
2840
2841             /*
2842              * If CSafeStore is on, then we don't awaken the guy
2843              * waiting for the store until the whole store has finished.
2844              * Otherwise, we do it now.  Note that if CSafeStore is on,
2845              * the BStore routine actually wakes up the user, instead
2846              * of us.
2847              * I think this is redundant now because this sort of thing
2848              * is already being handled by the higher-level code.
2849              */
2850             if ((avc->states & CSafeStore) == 0) {
2851                 tb->code = 0;
2852                 tb->flags |= BUVALID;
2853                 if (tb->flags & BUWAIT) {
2854                     tb->flags &= ~BUWAIT;
2855                     afs_osi_Wakeup(tb);
2856                 }
2857             }
2858             break;
2859         }
2860     }
2861     return 0;
2862 }
2863
2864
2865 /*
2866  * afs_InitCacheFile
2867  *
2868  * Description:
2869  *      Given a file name and inode, set up that file to be an
2870  *      active member in the AFS cache.  This also involves checking
2871  *      the usability of its data.
2872  *
2873  * Parameters:
2874  *      afile  : Name of the cache file to initialize.
2875  *      ainode : Inode of the file.
2876  *
2877  * Environment:
2878  *      This function is called only during initialization.
2879  */
2880
2881 int afs_InitCacheFile(char *afile, ino_t ainode)
2882 {
2883     register afs_int32 code;
2884 #if defined(AFS_LINUX22_ENV)
2885     struct dentry *filevp;
2886 #else
2887     struct vnode *filevp;
2888 #endif
2889     afs_int32 index;
2890     int fileIsBad;
2891     struct osi_file *tfile;
2892     struct osi_stat tstat;
2893     register struct dcache *tdc;
2894
2895     AFS_STATCNT(afs_InitCacheFile);
2896     index = afs_stats_cmperf.cacheNumEntries;
2897     if (index >= afs_cacheFiles) return EINVAL;
2898
2899     MObtainWriteLock(&afs_xdcache,282);
2900     tdc = afs_GetDSlot(index, NULL);
2901     ReleaseReadLock(&tdc->tlock);
2902     MReleaseWriteLock(&afs_xdcache);
2903
2904     ObtainWriteLock(&tdc->lock, 621);
2905     MObtainWriteLock(&afs_xdcache, 622);
2906     if (afile) {
2907         code = gop_lookupname(afile,
2908                               AFS_UIOSYS,
2909                               0,
2910                               NULL,
2911                               &filevp);
2912         if (code) {
2913             ReleaseWriteLock(&afs_xdcache);
2914             ReleaseWriteLock(&tdc->lock);
2915             afs_PutDCache(tdc);
2916             return code;
2917         }
2918         /*
2919          * We have a VN_HOLD on filevp.  Get the useful info out and
2920          * return.  We make use of the fact that the cache is in the
2921          * UFS file system, and just record the inode number.
2922          */
2923 #ifdef AFS_LINUX22_ENV
2924         tdc->f.inode = VTOI(filevp->d_inode)->i_number;
2925         dput(filevp);
2926 #else
2927         tdc->f.inode = afs_vnodeToInumber(filevp);
2928 #ifdef AFS_DEC_ENV
2929         grele(filevp);
2930 #else
2931         AFS_RELE((struct vnode *)filevp);
2932 #endif
2933 #endif /* AFS_LINUX22_ENV */
2934     }
2935     else {
2936         tdc->f.inode = ainode;
2937     }
2938     fileIsBad = 0;
2939     if ((tdc->f.states & DWriting) ||
2940         tdc->f.fid.Fid.Volume == 0) fileIsBad = 1;
2941     tfile = osi_UFSOpen(tdc->f.inode);
2942     code = afs_osi_Stat(tfile, &tstat);
2943     if (code) osi_Panic("initcachefile stat");
2944
2945     /*
2946      * If file size doesn't match the cache info file, it's probably bad.
2947      */
2948     if (tdc->f.chunkBytes != tstat.size) fileIsBad = 1;
2949     tdc->f.chunkBytes = 0;
2950
2951     /*
2952      * If file changed within T (120?) seconds of cache info file, it's
2953      * probably bad.  In addition, if slot changed within last T seconds,
2954      * the cache info file may be incorrectly identified, and so slot
2955      * may be bad.
2956      */
2957     if (cacheInfoModTime < tstat.mtime + 120) fileIsBad = 1;
2958     if (cacheInfoModTime < tdc->f.modTime + 120) fileIsBad = 1;
2959     /* In case write through is behind, make sure cache items entry is
2960      * at least as new as the chunk.
2961      */
2962     if (tdc->f.modTime < tstat.mtime) fileIsBad = 1;
2963     if (fileIsBad) {
2964         tdc->f.fid.Fid.Volume = 0;  /* not in the hash table */
2965         if (tstat.size != 0)
2966             osi_UFSTruncate(tfile, 0);
2967         /* put entry in free cache slot list */
2968         afs_dvnextTbl[tdc->index] = afs_freeDCList;
2969         afs_freeDCList = index;
2970         afs_freeDCCount++;
2971         afs_indexFlags[index] |= IFFree;
2972         afs_indexUnique[index] = 0;
2973     }
2974     else {
2975         /*
2976          * We must put this entry in the appropriate hash tables.
2977          * Note that i is still set from the above DCHash call
2978          */
2979         code = DCHash(&tdc->f.fid, tdc->f.chunk);
2980         afs_dcnextTbl[tdc->index] = afs_dchashTbl[code];
2981         afs_dchashTbl[code] = tdc->index;
2982         code = DVHash(&tdc->f.fid);
2983         afs_dvnextTbl[tdc->index] = afs_dvhashTbl[code];
2984         afs_dvhashTbl[code] = tdc->index;
2985         afs_AdjustSize(tdc, tstat.size);    /* adjust to new size */
2986         if (tstat.size > 0)
2987             /* has nontrivial amt of data */
2988             afs_indexFlags[index] |= IFEverUsed;
2989         afs_stats_cmperf.cacheFilesReused++;
2990         /*
2991          * Initialize index times to file's mod times; init indexCounter
2992          * to max thereof
2993          */
2994         hset32(afs_indexTimes[index], tstat.atime);
2995         if (hgetlo(afs_indexCounter) < tstat.atime) {
2996             hset32(afs_indexCounter, tstat.atime);
2997         }
2998         afs_indexUnique[index] = tdc->f.fid.Fid.Unique;
2999     } /*File is not bad*/
3000
3001     osi_UFSClose(tfile);
3002     tdc->f.states &= ~DWriting;
3003     tdc->dflags &= ~DFEntryMod;
3004     /* don't set f.modTime; we're just cleaning up */
3005     afs_WriteDCache(tdc, 0);
3006     ReleaseWriteLock(&afs_xdcache);
3007     ReleaseWriteLock(&tdc->lock);
3008     afs_PutDCache(tdc);
3009     afs_stats_cmperf.cacheNumEntries++;
3010     return 0;
3011 }
3012
3013
3014 /*Max # of struct dcache's resident at any time*/
3015 /*
3016  * If 'dchint' is enabled then in-memory dcache min is increased because of
3017  * crashes...
3018  */
3019 #define DDSIZE 200
3020
3021 /*
3022  * afs_dcacheInit
3023  *
3024  * Description:
3025  *      Initialize dcache related variables.
3026  */
3027 void afs_dcacheInit(int afiles, int ablocks, int aDentries, int achunk,
3028                     int aflags)
3029 {
3030     register struct dcache *tdp;
3031     int i;
3032     int code;
3033
3034     afs_freeDCList = NULLIDX;
3035     afs_discardDCList = NULLIDX;
3036     afs_freeDCCount = 0;
3037     afs_freeDSList = NULL;
3038     hzero(afs_indexCounter);
3039
3040     LOCK_INIT(&afs_xdcache, "afs_xdcache");
3041
3042     /*
3043      * Set chunk size
3044      */
3045     if (achunk) {
3046         if (achunk < 0 || achunk > 30)
3047             achunk = 13;                /* Use default */
3048         AFS_SETCHUNKSIZE(achunk);
3049     }
3050
3051     if(!aDentries)
3052         aDentries = DDSIZE;
3053
3054     if(aflags & AFSCALL_INIT_MEMCACHE) {
3055         /*
3056          * Use a memory cache instead of a disk cache
3057          */
3058         cacheDiskType = AFS_FCACHE_TYPE_MEM;
3059         afs_cacheType = &afs_MemCacheOps;
3060         afiles = (afiles < aDentries) ? afiles : aDentries; /* min */
3061         ablocks = afiles * (AFS_FIRSTCSIZE/1024);
3062         /* ablocks is reported in 1K blocks */
3063         code = afs_InitMemCache(afiles * AFS_FIRSTCSIZE, AFS_FIRSTCSIZE, aflags);
3064         if (code != 0) {
3065             printf("afsd: memory cache too large for available memory.\n");
3066             printf("afsd: AFS files cannot be accessed.\n\n");
3067             dcacheDisabled = 1;
3068             afiles = ablocks = 0;
3069         }
3070         else
3071             printf("Memory cache: Allocating %d dcache entries...", aDentries);
3072     } else {
3073         cacheDiskType = AFS_FCACHE_TYPE_UFS;
3074         afs_cacheType = &afs_UfsCacheOps;
3075     }
3076
3077     if (aDentries > 512)
3078         afs_dhashsize = 2048;
3079     /* initialize hash tables */
3080     afs_dvhashTbl = (afs_int32 *) afs_osi_Alloc(afs_dhashsize * sizeof(afs_int32));
3081     afs_dchashTbl = (afs_int32 *) afs_osi_Alloc(afs_dhashsize * sizeof(afs_int32));
3082     for(i=0;i< afs_dhashsize;i++) {
3083         afs_dvhashTbl[i] = NULLIDX;
3084         afs_dchashTbl[i] = NULLIDX;
3085     }
3086     afs_dvnextTbl = (afs_int32 *) afs_osi_Alloc(afiles * sizeof(afs_int32));
3087     afs_dcnextTbl = (afs_int32 *) afs_osi_Alloc(afiles * sizeof(afs_int32));
3088     for(i=0;i< afiles;i++) {
3089         afs_dvnextTbl[i] = NULLIDX;
3090         afs_dcnextTbl[i] = NULLIDX;
3091     }
3092
3093     /* Allocate and zero the pointer array to the dcache entries */
3094     afs_indexTable = (struct dcache **)
3095         afs_osi_Alloc(sizeof(struct dcache *) * afiles);
3096     memset((char *)afs_indexTable, 0, sizeof(struct dcache *) * afiles);
3097     afs_indexTimes = (afs_hyper_t *) afs_osi_Alloc(afiles * sizeof(afs_hyper_t));
3098     memset((char *)afs_indexTimes, 0, afiles * sizeof(afs_hyper_t));
3099     afs_indexUnique = (afs_int32 *) afs_osi_Alloc(afiles * sizeof(afs_uint32));
3100     memset((char *)afs_indexUnique, 0, afiles * sizeof(afs_uint32));
3101     afs_indexFlags = (u_char *) afs_osi_Alloc(afiles * sizeof(u_char));
3102     memset((char *)afs_indexFlags, 0, afiles * sizeof(char));
3103
3104     /* Allocate and thread the struct dcache entries themselves */
3105     tdp = afs_Initial_freeDSList =
3106         (struct dcache *) afs_osi_Alloc(aDentries * sizeof(struct dcache));
3107     memset((char *)tdp, 0, aDentries * sizeof(struct dcache));
3108 #ifdef  KERNEL_HAVE_PIN
3109     pin((char *)afs_indexTable, sizeof(struct dcache *) * afiles);/* XXX */
3110     pin((char *)afs_indexTimes, sizeof(afs_hyper_t) * afiles);  /* XXX */
3111     pin((char *)afs_indexFlags, sizeof(char) * afiles);         /* XXX */
3112     pin((char *)afs_indexUnique, sizeof(afs_int32) * afiles);   /* XXX */
3113     pin((char *)tdp, aDentries * sizeof(struct dcache));        /* XXX */
3114     pin((char *)afs_dvhashTbl, sizeof(afs_int32) * afs_dhashsize);      /* XXX */
3115     pin((char *)afs_dchashTbl, sizeof(afs_int32) * afs_dhashsize);      /* XXX */
3116     pin((char *)afs_dcnextTbl, sizeof(afs_int32) * afiles);             /* XXX */
3117     pin((char *)afs_dvnextTbl, sizeof(afs_int32) * afiles);             /* XXX */
3118 #endif
3119
3120     afs_freeDSList = &tdp[0];
3121     for(i=0; i < aDentries-1; i++) {
3122         tdp[i].lruq.next = (struct afs_q *) (&tdp[i+1]);
3123     }
3124     tdp[aDentries-1].lruq.next = (struct afs_q *) 0;
3125
3126     afs_stats_cmperf.cacheBlocksOrig = afs_stats_cmperf.cacheBlocksTotal = afs_cacheBlocks = ablocks;
3127     afs_ComputeCacheParms();    /* compute parms based on cache size */
3128
3129     afs_dcentries = aDentries;
3130     afs_blocksUsed = 0;
3131     QInit(&afs_DLRU);
3132 }
3133
3134 /*
3135  * shutdown_dcache
3136  *
3137  */
3138 void shutdown_dcache(void)
3139 {
3140     int i;
3141
3142     afs_osi_Free(afs_dvnextTbl, afs_cacheFiles * sizeof(afs_int32));
3143     afs_osi_Free(afs_dcnextTbl, afs_cacheFiles * sizeof(afs_int32));
3144     afs_osi_Free(afs_indexTable, afs_cacheFiles * sizeof(struct dcache *));
3145     afs_osi_Free(afs_indexTimes, afs_cacheFiles * sizeof(afs_hyper_t));
3146     afs_osi_Free(afs_indexUnique, afs_cacheFiles * sizeof(afs_uint32));
3147     afs_osi_Free(afs_indexFlags, afs_cacheFiles * sizeof(u_char));
3148     afs_osi_Free(afs_Initial_freeDSList, afs_dcentries * sizeof(struct dcache));
3149 #ifdef  KERNEL_HAVE_PIN
3150     unpin((char *)afs_dcnextTbl, afs_cacheFiles * sizeof(afs_int32));
3151     unpin((char *)afs_dvnextTbl, afs_cacheFiles * sizeof(afs_int32));
3152     unpin((char *)afs_indexTable, afs_cacheFiles * sizeof(struct dcache *));
3153     unpin((char *)afs_indexTimes, afs_cacheFiles * sizeof(afs_hyper_t));
3154     unpin((char *)afs_indexUnique, afs_cacheFiles * sizeof(afs_uint32));
3155     unpin((u_char *)afs_indexFlags, afs_cacheFiles * sizeof(u_char));
3156     unpin(afs_Initial_freeDSList, afs_dcentries * sizeof(struct dcache));
3157 #endif
3158
3159
3160     for(i=0;i< afs_dhashsize;i++) {
3161         afs_dvhashTbl[i] = NULLIDX;
3162         afs_dchashTbl[i] = NULLIDX;
3163     }
3164
3165
3166     afs_blocksUsed = afs_dcentries = 0;
3167     hzero(afs_indexCounter);
3168
3169     afs_freeDCCount =  0;
3170     afs_freeDCList = NULLIDX;
3171     afs_discardDCList = NULLIDX;
3172     afs_freeDSList = afs_Initial_freeDSList = 0;
3173
3174     LOCK_INIT(&afs_xdcache, "afs_xdcache");
3175     QInit(&afs_DLRU);
3176
3177 }