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